13 minute read

Hello again!

I’ve spent the last couple of weeks iterating on the new item stacking mechanic that I showed off in the last devlog. While there isn’t a ton of new features to show off, there are a lot of interesting design details to cover. I also wanted to give an inside look at my design process for the Stacker. Let’s get into it!

The Tube Design

I showed a version of the Stacker in the last devlog that was able to stack items. Here is how it worked:

The player is able to drop all of the items into the top of it and, once full, the stacker will output the final stack. I think the idea of filling a tube actually works really well for stacking and generally feels intuitive.

So what was wrong with this design? As you can see in the gif above, the resulting stack is not always the same. It relies on the order in which the items enter the tube. Unfortunately, because the items must enter the top of the tube, all of the conveyor belts sending items are competing to send their item to the same space. The game resolves this by having the senders take turns, but this is mechanic is not very intuitive and it is difficult to fully master. But let’s say that they do figure out to make the inputs take turns in the right order. If one of the conveyors happen to run out of items, there is nothing stopping the other conveyors from sending multiple items to the stacker. The player could address this by ordering all of the items on a single input belt, but that is not a simple task either.

In other words, if the player wants a specific order of 3 items (which is important for future crafting plans), there is no easy way to guarantee that with this design. So back to the drawing board we go…

Stack on Drop Design

As I mentioned in the last devlog, the original plan for item stacking was that it wouldn’t require a special building. Instead, stacks could be formed by simply dropping items on top of each other. This could be done by dropping items from cliffs or launching them with a Launcher.

I still think this idea is pretty cool, but it has some serious drawbacks. Firstly, this would lead to items accidentally stacking all of the place. Any time a conveyor backed up with items, other items might start dropping from cliffs onto occupied conveyors and forming stacks. Luckily, down ramps can help here for avoiding cliff drops, but not for launchers. A launcher would always stack if the destination was occupied.

The other issue with the design is that there is no easy way to guarantee a specific stack of items. At least compared to the tube design, this is a bit easier since the stack can be formed gradually: a cliff could drop one item on top and then later another cliff can drop a third item on top of the other two. We no longer have to rely on weird tie-breaking behavior, however, there is nothing stopping the items from continuing on if there happens to not be an item ready to drop onto it.

To summarize, with this design if conveyors back up we get accidental stacking, and if conveyors run low on items we get incomplete or incorrect stacks. Doesn’t sound very fun to new players at the start of the game.

Other Designs

In effort to fix these problems, I spent many days talking to a bunch of folks on the Discord and brainstorming new ideas. A lot of different ideas were proposed but I’ll mention a few of them:

Bottom Feeder

This is similar to the tube design, but items enter at the bottom via a conveyor belt, pushing any existing items in the stacker up. Once full, it outputs the stack. The main advantage to this design is that it avoids weird tie-breaking scenarios since only one input conveyor can be connected at a time. However, it now forces the player to order the items going into the stacker in reverse which is counter intuitive. Also, the game doesn’t provide any tools to easily and consistently order items on a belt.

Slot Ladder

The slot ladder mproves on the tube design in a couple of ways. Firstly, items can enter at different heights wihch will correspond to their position in the final stack. Also, items don’t drop to the bottom of the stacker, so items entering at a given height will always be in that position in the stack. This idea had a lot of potential, but the center slot was awkward to use and items would clip through the supports.

Slot Ladder

Tractor Beam

This is basically the same idea as the slot ladder, but using some kind of tractor beam visual instead of discrete slots. While cool looking, it isn’t clear how many items it can hold or which slots are empty.


The welder is inspired by Infinifactory’s building by the same name. Each welder is aimed at a space in front of it. Any item passing through this space will be held in place. The player would be able to stack multiple welders on top of each other and they would connect up. Once all connected welders have an item, they would “weld” them together into a stack and release it. Functionally, its mostly identical to the slot ladder and tractor beam ideas, except the structure of the welders are on an adjacent tile to where the items are being stacked.


Stacking Arms

There are currently no arms in Automation Station, but there could be arms designed specifically for stacking. They would be able to pick up items from conveyor belts and then hold the item at a given height. Combinining multiple of these arms would allow the player to create a stack. The main problem with this idea is that it is unclear how the player would avoid outputting a partial stack too early if the bottom arm(s) already had their item but the top arm did not.

Stacking Arm


The “transposer” was a super cool suggestion from a member of the Discord. The basic ideas was that this building would be able to pick up multiple items from a horizontal row of hex tiles at once. Then it would “transpose” those items into a vertical stack of items and output that. The main issue with this idea was that it required the stacker to be a large multi-tile building, which doesn’t play nicely with the pushing mechanics in the game. It also didn’t really feel like the items were being “stacked” since the height of the inputs didn’t matter.

Black Box

The black box was a suggestion to address some of the art issues I was facing with the stacker designs. As the name suggests, the idea was to make the stacker more of a black box. Inputs would be added to the input ports and the final stack would come out the other side. Functionally, it would be similar to the slot ladder, but would require the inputs to be received from specific input directions rather than any direction.

In general, I’ve been opting for more open designs that clearly communicate the state of the building. Functionally, this idea would work great, but it would be difficult to see what is inside the stacker.

Identifying Requirements

After several days of brainstorming, I was still having trouble coming up with an idea that I was completely happy about. A common issue was that I would figure some behavior for the stacker that I liked, but couldn’t come up with a good visual design for it that was intuitive and fit in with the rest of the game’s visuals. It was around this time that a Discord member suggested that I formalize the requirements for the stacker. That way we could evaluate the designs against these requirements to figure out which one is best.

Here are the requirements I came up with:

  • The player should be able to stack items vertically in stacks of 2 and 3 items, possibly more.
  • A new player to the game should be able to intuitively construct a stacking setup that creates stacks of two items for early game crafting recipes. Its okay for three item stacks to be more complicated to produce.
  • Items should only stack when and where the players wants them to. In other words, stacking should be opt-in and shouldn’t happen accidentally.
  • The player should be able to construct a stacking setup that guarantees a specific stack order, regardless of input rates (without resorting to advanced circuits or logic components). In other words, the timing of inputs to a stacking setup should not change the resulting stack order
  • The player should feel like they are vertically stacking items on top of each other. In other words, the act of creating a stack should somehow leverage the heights of the inputs.
  • If a stack is partially complete or only some of the inputs have been provided, the player should be able to easily see what items are currently in the stack and what slots in the stack are missing items.

Refining the Design

With these new set of requirements, I was able to figure out which ideas had the most potential. The “slot ladder” and “tractor beam” both offered the exact gameplay experience I was looking for. The player will be able to build a reliable stacking setup where the heights of the inputs directly corresponds to the heights of the items in the stack. And there was a natural way to block a partial stack from leaving by containing in some kind of structure. However, I still wasn’t really sold on the visual design of either. The slot ladder was funky to use, especially when items were side-loaded into the middle slot. And the tractor beam was a cool aesthetic, but it wasn’t obvious how many slots it had or which slots were empty.

I iterated on this idea further and eventually came up with this design.

New Stackers

It is basically an evolution of the slot ladder, but it removes the middle slots. Instead, there is only a top slot. There are currently two version of the stacker, the short 2-item stack and the tall stacker designed for 3 items. In order to make a stack of three items, you chain together the short and tall stacker like so:

However, it is also possible to only use the short stacker if you send a stack to the top slot.

As a result, I thought about removing the tall stacker entirely, but I think the tall stacker is more intuitve to new players. This will be one of things I’ll evaluate in a future playtests.

Looking back at the design requirements, this design seems to satisfy all of them. The player can easily stack two items and three isn’t too much more difficult. Stacking is entirely opt-in. Once constructed, a given stacking setup is 100% reliable regardless of input rates. It is easy to see what is currently inside the stacker and what it is waiting for. And finally, it relies on physically adding the inputs at different heights, which helps the player feel like they are stacking. Awesome!

However, I’m still not totally happy with the stacker’s visual design. I think it needs to be a bit bulkier and more visible when zoomed out. But I think it is a great starting place to start gathering feedback on the stacking mechanic. I’d love to hear your thoughts or if you have other suggestions for how the stacking could work.

Item Sizes

While iterating on the stacker, I realized that I would need to adjust the sizes of items in the game. The current item size was problematic for stacking as the items didn’t match the height of the conveyor belts or cliffs. That meant that if a conveyor belt had an item that it was trying to add to the top of the stacker, it was unclear how high the conveyor belt needed to be. There were similar problems with the height requirements for dropping items into the crucible and burner.

Since the items were already pretty close to the height of a cliff, I first tried making the items a little bigger to match the height exactly. That way a conveyor belt on a cliff is exactly high enough to stack an item on top of an item below it on another conveyor belt. Here is what the larger items look like:

Large Items

I didn’t mind the size of a single large item, but a stack of items could cover large parts of the screen, blocking parts of the factory. There were also clipping issues when stacks when up and down ramps.

Then I tried making the items small enough to match the height of a conveyor belt (which is half the height of a cliff). What’s nice about this size is that cliffs could also be made shorter, making everything (conveyors, items, and cliffs) all the same height, creating a sort of height standard for the game. Here is what that looks like:

Small Items

As you can see, there are no longer problems with items covering up too much of the screen nor clipping issues. However, I personally felt like the items were way too small for the belts. I’m sure a big part of it is how used to the old size I had become, but it still feels very disproportioned even after playtesting it for a week.

I wasn’t until the very end of last week that I remembered that I already had a shorter item in the game: the stator. The stator is going to be an intermediate item used for crafting motors and other gadgets. All of the other items in the game were roughly similar in height, but the stator model was shorter, almost exactly matching the height of a conveyor. So I tried seeing what it looked like to stack the stators. Here is the result:

When I saw this, I was immediately sold on it. The items felt sufficiently big, and they looked great when stacked, and, in my opinion, much better than a stack of round items that I had been testing out earlier. And if all items were of a similar shape, I could have a much more intuitive height system in the game where conveyors and items are both 1 “unit” high. Yay! 🎉


The shape of these items reminded me of a suggestion my friend had for item stacking: burgers 🍔. I quickly modeled some buns and a (vegan) patty and threw them in the game. I also had to temporarily change iron, copper, and coal nodes to give burger parts instead of the usual ore. Here is the result:

No idea if burgers will remain in the game, but I think they do a good job of showing what stacking will look like and what is possible.


There were a smaller set of changes this sprint as it was mostly focused design, but here is the changelog:

  • New short and tall stacker models.
  • New stacker behavior where items can either be dropped into the top slot or enter the bottom via conveyor belt.
  • Fixed interrupt handling for when an existing stacker is picked up and moved
  • Support manual stacking interactions with the new stacker
  • Add option to tweak item sizes at runtime, for development purposes only.
  • Changed the curcible behavior back to how it used to work by spawning the final ingot inside the crucible rather than next to it. Works better for manual interactions and the rest of the item transfer logic.
  • New models for top bun, bottom bun, and patty
  • Added burger parts to game.

That’s all for this devlog! I just want to give a huge thanks to those of you that were willing to chat about stackers and item sizes for hours on Discord. Its really nice to have people to help me get unstuck on a design issue, espcially as a solo-developer. If you are interesting in joining in on these design discussions, feel free to join our Discord using the link below. Thanks for reading!




Leave a comment