03 Attempting to Design a Multi-Species Tree Farm
In the previous section, we completed the simplest tree farm. However, this tree farm has a serious problem: it can only process birch trees and cannot handle other tree species. To solve this problem, in this section we attempt to design a multi-species tree farm.
1 Core Architecture Design
For a multi-species tree farm, the architecture needs to accommodate the growth requirements of every tree species it handles. In practice, this means taking the union—in each aspect of the design, we must meet the requirements of the most demanding species. For now, we'll focus on the five classic tree species: Birch, Oak, Jungle, Spruce, and Acacia. We'll walk through them one by one in the typical design order.
Birch has the fewest growth restrictions, so we'll start with spruce.
1.1 Spruce Architecture Requirements
Spruce requires a 5x5 area centered on the sapling with no blocks obstructing growth. For trunk processing, we can use triple recursion, pseudo-double recursion, or honey-slime double recursion.
Example architecture:
The main pusher design will significantly impact your oak height-limiting options, so choose carefully
1.2 Acacia Architecture Requirements
Acacia grows up to 2 logs on the same y-level, extending along the x or z axis and at most 4 blocks away from the sapling. These logs can form straight lines, corners, and other configurations, as shown below.
This means the main pusher alone cannot clear all the logs, so we need side branch processing. There are two design approaches: center consolidation and additional log outputs.
For center consolidation, we first push the logs on the main pusher side to the center, then push the left-side logs to the center and eject them with the main pusher, and finally do the same for the right-side logs.
A typical example of additional log outputs is nutstory's architecture. The animation demonstrates how it works.
@Dreaming_Galaxy, XJH_Jorhai, Feng_Bl, Bright_Observer PUTF standard
Some architectures use both methods at once, such as PUTF -2. PUTF// also offers a different approach: adding one block to the main pusher, consolidating side branches into the middle 2 blocks, then pushing them out directly. However, this method doesn't work for cherry trees and isn't particularly useful in GTMC's 1.20.1
1.3 Jungle Architecture Requirements
Jungle tree trunks can grow up to 12 blocks tall, so we need a tall enough main pusher to handle as many logs as possible.
Multi-species tree farms that don't process full height do exist—typically 8 blocks tall (for easier oak height limiting) or 10 blocks tall (for easier wiring)—but we don't recommend this approach
Jungle saplings have a 1/40 drop rate, so we need extra leaf processing for jungle trees. The simplest approach is to use double recursion or honey-slime walls to cover as many potential growth positions as possible. From a top-down view, if no more than 5 columns of leaves within the 5x5 range go unprocessed, the farm can still collect enough jungle saplings.
@nutstory 5 columns cannot be processed
This estimation method is somewhat imprecise. Jungle leaves are denser near the trunk. Strictly speaking, you'd need to calculate the average processing coverage across all possible leaf growth patterns. Generally, an average above 42 is enough to get sufficient jungle saplings
1.4 Oak Architecture Requirements
Oak trees can randomly grow into large oaks (commonly called drumstick trees), so we need to height-limit them to prevent this. The height-limiting block goes at the 9th block above the dirt.
Designs that can directly handle drumstick trees do exist, but so far none of them can collect enough jungle saplings, so they fall outside the scope of multi-species tree farms
For our example, we'll use honey-slime triple recursion on the main pusher, center consolidation for side branches, honey-slime walls for leaf processing, and manually placed obsidian for height limiting.
If you're familiar with older tree farms, you'll notice this is nearly identical to PTHSUTF's architecture. Given how varied redstone engineering designs can be, the best way to learn a particular design is to "imitate" it. In other words, when you're still learning redstone engineering, don't be afraid to "copy"—even just replicating the wiring of a well-built machine teaches you a lot
2 Block Stream to Drops Architecture Design
Because multi-species tree farms produce an irregular block stream output, we need to reorganize the block stream before feeding it into a specially designed explosion chamber.
2.1 Reorganization
In our example design, all logs are output to the front of the trunk, with at most two blocks output per operating cycle.
If you're familiar with DLHSUTF/PTHSUTF/DLPTUTF, you'll immediately think of using two rows of pistons side by side to merge the two log outputs (at unpredictable intervals) into a single 2-wide output. Alternatively, we can use a structure similar to a side-suction base to convert the two outputs with uncertain intervals into two outputs with a fixed interval (typically 6gt).
@Dawnemo DLPTUTF
Since acacia's two logs on the same y-level can be distributed at the center and within 1 block around it (as shown below), even with additional log outputs, the trunk still needs this type of reorganization. For the extra outputs, we can simply add explosion chambers to handle their block stream to drops
2.2 Explosion Chamber
For now, we'll just attach some explosion chambers to process the block stream. We try to avoid pushing out a 2-block-thick stream at once, because that greatly reduces the explosion chamber's processing efficiency and the final drop recovery rate.
For multi-species tree farms, we can use two specialized explosion structures: pure milk explosion chambers (commonly called "milk explosions") and b36 explosion chambers (commonly called "push explosions") to handle large volumes of irregular block streams. These are widely used in modern high-speed multi-species farms, but since nobody has updated the explosion chamber for our example, we'll cover them together in the speed-up chapter (
Milk explosion:
@从来只喝纯牛奶
@Qonctrol, Dreaming_Galaxy, BFladderbean, Feng_Bl PUTF std2
Push explosion:
@嘟了个嘟噜
3 Wiring—Mode Switching and Speed Limiter
Once you've worked out the timing, you just need to activate each piston group as precisely as possible according to your design. Here, we want to focus specifically on the wiring for mode switching.
3.1 Acacia Timing Switching
If you look closely, you'll notice that for every tree species except acacia, we can push out both side honey-slime walls (hereafter called side walls) at the same time, shortening the processing cycle. We can go further and push the main pusher simultaneously too, cutting the cycle down even more. This creates different operating timings.
The solution isn't complicated. Switching from normal timing to acacia timing is simply adding delay to the two side walls. So we only need to run a second line with more delay to the side walls, then build a device that switches between the two lines.
3.2 Automatic Oak Height Limiting
Many players find manually placing obsidian tedious. There's a solution for that: automatic height limiting.
Since automatic height-limiting methods vary widely between designs, we'll only cover the one used in our example architecture.
The idea is simple: place a block that the main pusher can't push in the right spot to achieve height limiting. But to send that block down (usually via a flying machine), we can only use pushable blocks. The solution is to fill the main pusher's push direction with logs, then insert an activated piston on the reorganization side to prevent it from moving in the main pusher's direction.
There are other solutions too. Here are some examples:
Slime stick cutting:@Jellie_
Flying terracotta:
@XJH_Jorhai
Wall-cutting main pusher with flying machine insertion:
@Feng_Bl
3.3 * Jungle and Acacia Height Increase (1.14 and below content)
In version 1.14 and below, jungle and acacia growth detection checks a 3x3 area for the trunk and 5x5 for the canopy. This means we can place blocks within the 5x5 area below a certain height (typically 5 blocks above the dirt) to force jungle and acacia trees that would grow too short to reach a minimum height, improving the efficiency of both species.
Since this mechanism prevents jungle or acacia below a certain height from growing at all, it increases bone meal consumption. Also, even in 1.20.1, dark oak retains the same growth requirements (centered on the northwest corner sapling), so we can still "height-boost" dark oak
3.4 Speed Limiter
There's one more issue. Trees can grow before our architecture has fully reset, which would trigger the detection structure prematurely and break the farm. So we need to add a speed limiter to the detection structure. The limiter's timing must also account for the operating timing (reset time) of the rest of the farm in each mode.
For QC detection, we can directly power the retraction piston, or attach something to the structure that pushes out after detection to prevent it from activating too early—like PTHSUTF's solution.
Since QC detection speed limiting is hard to modularize, building your own is the best approach (
For comparator detection, we can use a similar approach—cutting off the signal output before a certain node
For push limit detection, we can sever the connection between the detection structure and the dirt
For BUD detection, if you want to ensure stability, you must use a 4gt reset BUD and add delay at the signal output. If you use a 6gt reset BUD, there may be cases where trees growing at 4gt fail to trigger—
like the noob Galaxy's early powder-free perfect-timing oak modes and TT's 6gt jungle tree farm, which both broke this way
At this point, we have completed a relatively simple multi-species tree farm.
[[Here is the example we made!|TreeFarm/exampleworld/#03 尝试设计一台全树种树场.zip]]