úÎœ!‘oģ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž¯°ą˛ŗ´ ĩ ļ ˇ ¸ š ē Noneģ7Generate tuple instances for the following tuple sizes.ģŧģŧģŧNone9:;<=DIRTCasts for entities and slices#Class of storages for global values$Holds components indexed by entities +The type of components stored by this Store .Return type for safe reads writes to the store $Retrieves a component from the store Writes a component+Destroys the component for the given index.8Returns whether there is a component for the given index+Returns an unboxed vector of member indicesZUnsafe index to the store. What happens if the component does not exist is left undefined.$Either writes or deletes a component1Removes all components. Equivalent to calling  explDestroy on each member(Monadically iterates over member indices(Monadically iterates over member indices|Modifies an element in the store. Equivalent to reading a value, and then writing the result of the function application.Maps over all elements of this store. Equivalent to getting a list of all entities with this component, and then explModifying each of them.Represents a safe access to cO. A safe access is either a read that might fail, or a write that might delete.A world * a component if it can produce its Storage!žA component is defined by the type of its storage The storage in turn supplies runtime types for the component. For the component to be valid, its Storage must be in instance of Store.#5A system is a newtype around `ReaderT w IO a`, where w is the game world variable.&JA slice is a list of entities, represented by a Data.Unbox.Vector of Ints.)uAn Entity is really just an Int. The type variable is used to keep track of reads and writes, but can be freely cast.,  !"#$%&'()*+,-789'  !"#$%&'()*+:)*+&'(#$%!"  -,99999999999999987  !"#$%&'()*+,-789None 9:;<=TghIRun a system with a game worldJRun a system with a game worldK/A slice containing all entities with component cL/Returns whether the given entity has component c^ For composite components, this indicates whether the component has all its constituentsMDestroys the component c for the given entityN]Removes all components. Equivalent to manually iterating and deleting, but usually optimized.O|Gets the component for a given entity. This is a safe access, because the entity might not have the requested components.PIWrites a component to a given entity. Will overwrite existing components.QSame as set., but uses Safe to possibly delete a componentR~Applies a function if possible. Equivalent to reading, mapping, and writing, but stores can provide optimized implementations.SšMonadically iterate a system over all entities that have that component. Note that writing to the store while iterating over it is undefined behaviour.TšMonadically iterate a system over all entities that have that component. Note that writing to the store while iterating over it is undefined behaviour.U(Maps a pure function over all componentsVŊ version of UWindexed V , also gives the current entity.XimapM version of cmap. Can be used to get a list of entities As the type signature implies, and unlike U9, the return value is not written to the component store.Yindexed X , also gives the current entity.Z0Maps a function that might delete its components[)Maps a function over all entities with a r, and writes their w\)Maps a function over all entities with a r, and writes or deletes their w]For all entities with a w, this map reads their r and writes their w^For all entities with a w, this map reads their r and writes or deletes their w_Reads a global value`Writes a global valueaModifies a global valueIJKLMNOPQRSTUVWXYZ[\]^_`aIJKLMNOPQRSTUVWXYZ[\]^_`aIJKLMNOPQRSTUVWXYZ[\]^_`aIJKLMNOPQRSTUVWXYZ[\]^_`aNone,9:;<=DRTfghcäA cache around another store. The wrapped store must produce safe representations using Maybe. Note that iterating over a cache is linear in its size, so large, sparsely populated caches will actually decrease performance.d"Global value. Initialized with žŋBConstant value. Not very practical, but fun to write. Contains žeoA Unique contains at most one component. Writing to it overwrites both the previous component and its owner.f@A store that keeps membership, but holds no values. Produces flag runtime values.gClass for flags, used by Set" to yield runtime representations.imA map from Data.Intmap.Strict. O(log(n)) for most operations. Yields safe runtime representations of type Maybe c.bcĀdÁŋÂeÃfÄghiÅÆjklmnopqrsbcdefghiifghcedbbcĀdÁŋÂeÃfÄghiÅÆjklmnopqrsNone9:;<=DIRTght!Secretly just an int in a newtypeu,Bumps the EntityCounter and yields its valuevCWrites the given components to a new entity, and yields that entityw'Explicitly invoke the garbage collectorx imapM returny cmapM returnz cimapM return{“Quantize turns a world-space coordinate into a table-space coordinate by dividing by the given cell size and rounding towards negative infinity.||Turns a table-space vector into an integral index, given some table size vector. Yields Nothing for out-of-bounds queries}RTests whether a vector is in the region given by 0 and the size vector (inclusive)~œFor 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.6flatten, but yields garbage for out-of-bounds vectors.€5Runs a system and gives its execution time in secondsKRuns a system, discards its output, and gives its execution time in secondstĮČuvwxyz{Quantization cell sizeVector to be quantized|}~Lower bound for the regionHigher bound for the region€‚ tuvwxyz{|}~€ wtuv{|}~€xyztĮČuvwxyz{|}~€‚None‡Same as ˆ , but has no tˆ 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 <*> ... <*> initCounter|ɇˆ‡ˆˆ‡ɇˆNone9:;T‰Slice version of foldM_ŠGets the size of a slice (O(n))‹&Checks whether an entity is in a sliceŒMore polymorphic version of ‹%Tests whether a slice is empty (O(1))Ž$Construct a slice from a list of IDsMonadically filter a slice.Concatenates two slices. Equivalent to mappend‘Slice version of forM_’Slice version of forM“MIterates over a slice, and reads the components of the Slice's type argument.”MIterates over a slice, and reads the components of the Slice's type argument.•Slice version of mapM_–Slice version of mapM—MIterates over a slice, and reads the components of the Slice's type argument.˜MIterates over a slice, and reads the components of the Slice's type argument.‰Š‹ŒŽ‘’“”•–—˜™‰Š‹ŒŽ‘’“”•–—˜™‰Š‹ŒŽ‘’“”•–—˜™‰Š‹ŒŽ‘’“”•–—˜™None*9:;<=DRTgh š3Hashtable that maintains buckets of entities whose  fromEnum c produces the same value›"Composite Log consisting of 3 Logsœ"Composite Log consisting of 2 Logs!Composite Log consisting of 1 LogžA Logger l of some store updates its Log l& with the writes and deletes to store sŸ#FromPure turns a PureLog into a LogĄ&A Log is a PureLog with mutable state.ĻA PureLog is a piece of state l c! that is updated when components c( are written or destroyed. Note that  l :: * -> *Ē.Produces the log indicated by the return type.Ģ Query the  EnumTable by an index (the result of fromEnum$). Will return an empty slice if  index < 0 of index >= fromEnum (maxBound).Ŧ Query the  EnumTableQ by an example enum. Will not perform bound checks, so crashes if `fromEnum c  0 && fromEnum c fromEnum maxBound `.!šĘ›ËœĖÍžÎŸ ĪĐĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž¯°ą˛ŗš›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦĄĸŖ¤ĨĻ§¨ŠŸ žĒœ›šĢŦšʛ˜Ė͞Ο ĪĐĄĸŖ¤ĨĻ§¨ŠĒĢŦ­Ž¯°ą˛ŗ None9:;T´¨Executes a list of systems concurrently, and blocks until all have finished. Provides zero protection against race conditions and other hazards, so use with caution.ĩkExecutes a map in parallel by requesting a slice of all components, and spawning threads iterating over  grainSize components each.ļrmap version of pcmapˇcmap' version of pcmap¸rmap' version of pcmapšwmap version of pcmapēwmap' version of pcmap´Ņĩļˇ¸šē´ĩļˇ¸šē´ĩļšˇ¸ē´Ņĩļˇ¸šēNone4  !"#$%&)*+IJKLMNOPQRUVWXYZ[\]^_`adefghitvw4#$%!")*+& ifedgh MLKNOPQRUXVYW\[]^Z_`aIJwtvŌ  !"#$%&'()*+,-../0123445667889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ĄĸŖ¤ĨĻ§¨ŠĒĢŦ­­Ž¯°ą˛ŗ´ĩļˇ¸šēģŧŊžŋĀ Á Â Ã Ä Å Æ Į Č É ĘŖ ËĖÍqrÍstw΂ĪШŠĒĢŦŅŌ ĶÔ$apecs-0.2.4.2-2Z4I6ANk5Hb227kTTmNLgxApecs Apecs.Logs Apecs.Types Apecs.System Apecs.Stores Apecs.UtilApecs.TH Apecs.SliceApecs.ConcurrentApecs.THTuplesbaseControl.Monad.IO.ClassliftIO GHC.IORef readIOReftransformers-0.5.2.0Control.Monad.Trans.Classlift mtl-2.2.1-BLKBelFsPB3BoFeSWSOYj6Control.Monad.Reader.ClassasksaskCastcast GlobalStoreStoreStoresSafeRW initStoreexplGetexplSet explDestroy explExists explMembers explGetUnsafe explSetMaybe explReset explImapM_ explImapM explModifyexplCmap explCmapM_ explCimapM_ explCmapM explCimapMSafegetSafeHasgetStore ComponentStorageSystemunSystemSliceunSliceEntityunEntity$fCastSliceSlice$fCastEntityEntity $fEqEntity $fOrdEntity $fShowEntity $fShowSlice $fMonoidSlice$fFunctorSystem $fMonadSystem$fApplicativeSystem$fMonadIOSystem$fGlobalStore(,,)$fGlobalStore(,)D:R:Stores(,,,,,)$fStore(,,,,,) $fHasw(,,,,,)$fComponent(,,,,,) $fStore(,,,,) $fHasw(,,,,)$fComponent(,,,,) $fStore(,,,) $fHasw(,,,)$fComponent(,,,) $fStore(,,) $fHasw(,,)$fComponent(,,) $fStore(,) $fHasw(,)$fComponent(,) runSystemrunWithownersexistsdestroy resetStoregetsetset'modifyimapM_imapMcmapcmapM_cimapM_cmapMcimapMcmap'rmaprmap'wmapwmap' readGlobal writeGlobal modifyGlobalCachableCacheGlobalUniqueSetFlagflagMap $fStoreCache$fCachableCache $fCachableMap $fStoreGlobal$fGlobalStoreGlobal$fGlobalStoreConst $fStoreConst $fStoreUnique $fStoreSet $fStoreMap EntityCounter nextEntity newEntityrunGClistAllElistAllC listAllECquantizeflatteninboundsregionflatten' timeSystem timeSystem_$fComponentEntityCounter$fMonoidEntityCounter$fNumEntityCounter$fEqEntityCounter$fShowEntityCounter makeWorldNoEC makeWorldfoldM_sizeelemelem'nullfromListfilterMconcatforM_forMforMCforMC_mapM_mapMmapMCmapMC_toList EnumTableLVec3LVec2LVec1LoggerFromPureLoglogEmptylogOnSet logOnDestroylogResetPureLog pureEmpty pureOnSet pureOnDestroygetLogbyIndexbyEnum$fLogEnumTablec $fLogLVec3c $fLogLVec2c $fLogLVec1c $fStoreLogger$fLogFromPurec$fHasLogLoggerl concurrentlypcmapprmappcmap'prmap'pwmappwmap' makeInstancestupleInstances Data.FoldableGHC.BasememptyConstdefaultSetMaybe getCountergenNameHasLog explGetLog parallelize