## Description Autoverse is a mod for compacting vanilla-type automation contraptions, and adding new possibilities for automation. Autoverse is for the most part focused around doing things based on the sequence of arriving items. In other words, "commands" and data are stored and transferred encoded as the order of item sequences. For this purpose the mod has (among other things) (item) Pipes, FIFO Buffers, Filters, Splitters, Muxers, Sequencers and Sequence Detectors, which can be used to control and direct the item flow into different places, where it can do various things. Most of the machines in this mod can be programmed by the incoming item sequence, and then during "normal operation", they can be again reset by an arriving matching reset item sequence, after which they can be programmed again using different settings.

## Short Background The project for which this mod was originally developed for/started, is a "BioVoxel" project, which attempts to simulate things like living cells. For this project, it's very important that everything can be done completely without player interaction. That's why everything in this mod can be placed and configured automatically using the Programmable Block Placer, as long as the initial contraption has been programmed with a sequence of items that is able to correctly configure the Block Placer for each block that is to be placed. In other words, every block in this mod can be placed in any orientation, and any non-item-programmable properties of blocks (such as the FIFO Buffer's length for example) can be set by the Programmable Block Placer. ## Blocks Currently implemented blocks: - `Barrel` - A simple one-slot storage. The maximum stack size is adjustable, between 1 and 32768, in powers of two. It can be locked by a redstone signal (prevents automation like hoppers from inserting or extracting items.) - `Barrel (Pulsed)` - Similar to the regular `Barrel`, except it can't be locked by a redstone signal, but instead it will try to push one item below itself on a redstone signal's rising edge - `Block Breaker` - Breaks the block on it's front side, when it receives a block update. Tries to output items to it's back side, and if that fails, then also one block away on its back side (so that the breaker can be attached to a frame block from behind). - `Block Breaker (Greedy)` - Breaks blocks on all except its back side, when it receives a block update. Tries to output items to it's back side, and if that fails, then also one block away on its back side (so that the breaker can be attached to a frame block from behind). There is also a config option to change the break area into a 3x3x2 or a 5x5x3, so that frame quarries don't need that many breakers. - `Block Detector` - Can detect blocks in an area on its front side. It will output a matching item on successful detection. The maximum distance, angle, the detection interval and the types of blocks to detect are programmable. - `Block Placer (NBT)` - Can place blocks, and set their properties from the item's NBT data. Meant to be used with items read by the Block Reader. - `Block Placer (Programmable)` - Can place blocks, and set their properties, based on the currently configured properties. For all Autoverse blocks, the available properties and their order is listed in the blocks' tooltip. For other blocks, the properties are set like: 1) any PropertyDirection type properties (orientations) 2) any PropertyInteger type properties. If there are for example two facing properties, they are ordered alphabetically. - `Block Reader` - Can take blocks from the world, and encode their orientation etc. information and TileEntity data to the item's NBT data. (Meant to be used with the non-programmable Block Placer.) - `Crafter` - A programmable auto-crafter. - `FIFO Buffer` - A buffer for items. The items will leave in the same order as they arrived in (First In First Out). Attempts to push one item out on the rising edge of a redstone signal. Otherwise items need to be pushed in, and pulled out. - `FIFO Buffer (Pulsed)` - A variant which only advances the internal positions on redstone signal. (The exact behaviour of the extract position is a bit odd atm, and may be changed at some point.) - `FIFO Buffer (Auto-pushing)` - A variant which tries to actively push out items to an inventory on its output face. - `Filter` - A programmable item filter. Arriving items matching the filter are output on a separate side. - `Filter (Sequential)` - A variant of the Filter, which will output matching items only in a complete, matching sequence like it was programmed. - `Filter (Strict Sequential)` - A variant of the Filter, which will only output matching items to the filtered-out side if they match the entire sequence in order. - `Inventory Reader (Items)` - Outputs a redstone signal strength based on how full of items an inventory is. Very similar to a vanilla Comparator, except that it can be placed in any orientation, and it doesn't read anything except inventories. - `Inventory Reader (Slot)` - Outputs a redstone signal based on what percentage of the slots in an inventory have items. The amount of items per slot, or the maximum stack sizes of the slots are irrelevant. - `Muxer (Redstone-controlled)` - Accept in items from either the "secondary" input side, or other any sides, based on whether the block is powered by a redstone signal. - `Muxer (Priority)` - Items arriving from the "secondary" input side will always have priority over the other sides. - `Muxer (Sequence Length)` - Can be programmed with the item sequence lengths for input sides 1 and 2 respectively. The active input side will change after that configured number of items. - `Pipe (Basic)` - A basic item transport pipe. These are simple slot/inventory based pipes. Items will always try to go straight first, whenever possible. Items will never leave from the same side that they arrived from (they will not "bounce back"). Any side connections can be disabled by sneak + right clicking with an empty hand (and for these basic pipes, also by sneak + left clicking on the side connection). - `Pipe (Directional)` - A pipe where items can only leave via sides that have been set as outputs. - `Pipe (Extraction)` - A pipe that can pull items from inventories. The pulling sides can be enabled/disabled by sneak + left clicking. - `Pipe (Round-robin)` - A pipe which will prioritize sides that have been set as round-robin outputs. It will cycle between any such sides. Note that if the item fails to leave via round-robin output sides, it can then also leave from normal sides. This allows these round-robin pipes to also be used as insertion pipes, i.e. they would first try to insert into an adjacent inventory, but the items can then continue straight along as well if the insertion fails. - `Programmable Redstone Emitter (Basic)` - Can be toggled ON and OFF by a matching item sequence. The output sides are programmable. - `Programmable Redstone Emitter (Advanced)` - Every side can have its own ON and OFF command sequence. - Height Sensor` - Emits a redstone signal strength based on its y-position. Basically it will indicate the chunk section's y-value, because it can have only the values 0..15. In other words, the output value will increase/decrease by one every 16 blocks up/down. - `Sequence Detector` - Outputs a 1-redstone-tick pulse when it detects an arriving item sequence that matches the programmed detection sequence. - `Sequencer (Basic)` - A simple 1 to 18 slot inventory, but the extraction slot will advance by one every time an item is pulled out. - `Sequencer (Programmable)` - Can be programmed with a sequence, which will set and lock the inventory slots to those item types. The extraction slot will advance by one every time an item is pulled out. - `Splitter (Redstone)` - The output side will change based on a redstone signal (a separate "secondary" output side for when the block is powered). - `Splitter (Switchable)` - Can be programmed with two switching sequences. The output side will change to one of the two, when a matching sequence is detected. - `Splitter (Sequence Length)` - Can be programmed with two sequence lengths. The output side will switch after that many items have passed through. - `Trash Bin` - Just a simple trash bin, which destroys any items that are inserted. - `Trash Buffer` - A trash bin with a rather large initial buffer (36 slots, max 1024 items per slot). You can also think of it as a storage block with a void upgrade. - `RS-Latch` - A RS-latch in one block. Both input sides and the output side can be freely set. - `T-Latch` - A T-latch (toggle output state on input pulse) in one block. The output side can be freely rotated. ## Items Currently implemented items: - `Block Placer Property Configurator` - Allows for easier configuration of the block properties in the Programmable Block Placer. It will store any supported properties from the block it is used on, and it can then generate the property item sequence to program the properties in a Programmable Block Placer. - `Wand of the Lazy Sequencer` - Can store the item sequence of Autoverse machines, or simply the order of items in other inventories. The stored sequences can then be applied to Autoverse machines, or any inventories. ## Short demo videos A short and a bit silly demonstration video using some Programmable Block Placers and Block Breakers:

Programmable Block Placers and Block Breakers demo

Autoverse and Funky Locomotion demo

Another small demo - a rail builder using Autoverse and Funky Locomotion (and the Barrels from Ender Utilities just for their item rendering):

## Images

Block Detector

![Block Detector](https://i.imgur.com/eDBFNCX.png "Block Detector")

Block Placer (Programmable)

![Block Placer (Programmable)](https://i.imgur.com/8RMIEn2.png "Block Placer (Programmable)")

Crafter

![Crafter](https://i.imgur.com/LKWdk5p.png "Crafter")

FIFO Buffer

![FIFO Buffer](https://i.imgur.com/Ox1NpTq.png "FIFO Buffer")

Filter

![Filter](https://i.imgur.com/1vAPMGa.png "Filter")

Filter (Sequential)

![Filter (Sequential)](https://i.imgur.com/9VAma5O.png "Filter (Sequential)")

Muxer (Redstone-controlled)

![Muxer (Redstone-controlled)](https://i.imgur.com/fLfY4YZ.png "Muxer (Redstone-controlled)")

Muxer (Sequence Length)

![Muxer (Sequence Length)](https://i.imgur.com/i5o5e04.png "Muxer (Sequence Length)")

Pipes

![Pipes](https://i.imgur.com/kYscIRP.png "Pipes") ![Pipes](https://i.imgur.com/TN9nUWN.png "Pipes") ![Pipes](https://i.imgur.com/DTUrmCG.png "Pipes")

Pipe (Extraction)

![Pipe (Extraction)](https://i.imgur.com/bzsVBcm.png "Pipe (Extraction)")

Pipe (Round-robin)

![Pipe (Round-robin)](https://i.imgur.com/BxLvV2l.png "Pipe (Round-robin)")

Programmable Redstone Emitter (Basic)

![Programmable Redstone Emitter (Basic)](https://i.imgur.com/W0huF2K.png "Programmable Redstone Emitter (Basic)")

Programmable Redstone Emitter (Advanced)

![Programmable Redstone Emitter (Advanced)](https://i.imgur.com/t1cX4FI.png "Programmable Redstone Emitter (Advanced)")

Sequence Detector

![Sequence Detector](https://i.imgur.com/ZQZdL9U.png "Sequence Detector")

Sequencer (Basic)

![Sequencer (Basic)](https://i.imgur.com/9nXaOYq.png "Sequencer (Basic)")

Sequencer (Programmable)

![Sequencer (Programmable)](https://i.imgur.com/E4yBvH5.png "Sequencer (Programmable)")

Splitter (Switchable)

![Splitter (Switchable)](https://i.imgur.com/PwErqVd.png "Splitter (Switchable)")

Splitter (Sequence Length)

![Splitter (Sequence Length)](https://i.imgur.com/dymhbcN.png "Splitter (Sequence Length)")

Trash Buffer

![Trash Buffer](https://i.imgur.com/U7eLgBY.png "Trash Buffer")