Tutorial:360 degree ender pearl cannon

An ender pearl cannon is a machine that fires an ender pearl to a precise position using explosions for fast player transportation. A 360 degree ender pearl cannon is an ender pearl cannon that can fire within a few blocks of any position in range, in any direction.

A typical ender pearl cannon consists of a few key components:

• An ender pearl aligner that gets the ender pearl to an exact position reliably.
• A source of explosions that can control the amount of explosions produced (usually an array of TNT dupers, but TNT dispensers, ghast fireballs, and wind charges are used as well).
• A basket, which positions the TNT or fireballs so that the explosions occur in reliable positions near the ender pearl.
• A ROM (read-only memory) that stores the explosion counts for many destinations, so that common destinations may be easily used multiple times.
• A user interface to select a destination.

This article only covers the logic that governs the basket, since the other components are used in other devices and fit better in their own tutorial pages. This article assumes the reader already knows how to use redstone proficiently and only needs information about how to design a 360 cannon, not how to physically build one.

360 cannons are heavily reliant on linear algebra to work. An understanding of some basic concepts in linear algebra makes understanding 360 cannons much easier. If you are not familiar with linear algebra, it is recommended to skip this section. If you wish to become familiar with linear algebra, there are some fantastic introductory lectures by Gilbert Strang for free on YouTube.

The core game mechanic that makes it all possible is the fact that the velocity given by an explosion to an entity is always identical and is added to the entity's existing velocity. This allows us to treat velocities given by explosions as vectors:

• Two explosion velocities can be added using vector addition. Given two explosion velocities and , their sum is .
• An explosion velocity can be scaled by changing the number of explosions in that position. To scale by a negative number, an explosion can be done on the opposite side of the entity to give opposite velocity.

Due to us wanting to hit any position in the 2-dimensional X-Z plane, it will be sufficient to use 2 different explosion positions (and their 2 opposites). Hitting any position in 3D space would require 3 different explosion positions (and their 3 opposites). This is a consequence of the behavior of bases that we will not get into in this article.

Now, assume that we have a basket with A explosions in one position and B explosions in another position. The velocity given to the ender pearl can be written as where is the velocity given by each explosion in the first position and is the velocity given by each explosion in the second position. This formula can be expanded to and finally written as a matrix multiplication. This 3x2 matrix represents the transformation from explosion counts to ender pearl velocity. In general, we wish to do the opposite: given a target velocity , find the explosion counts that will produce it. This requires finding the inverse of the above matrix, which is not possible to do in general because it isn't square. However, it does have a Moore-Penrose pseudoinverse, which is a matrix such that is the solution for that gets closest to the target velocity (where distance is measured in the Euclidean sense). This means that you can compute the TNT-to-velocity matrix and its pseudoinverse once when first building a basket, and then it is easy to calculate the required TNT to achieve any target velocity by multiplying it by . It is usually recommended to calculate the pseudoinverse using a linear algebra package (it is usually called pinv; for example, pinv from the LinearAlgebra library for Julia, or numpy.linalg.pinv from the NumPy library for Python, or pinv from MATLAB) since the typical expression has significant roundoff error compared to the more numerically robust algorithms used in linear algebra packages. However, since we will need to turn the solution into integers anyway (since TNT comes in integer amounts), the roundoff error does not make a difference in the context of a TNT cannon.

One final technicality is that the pseudoinverse (and other methods for solving the linear least-squares problem) gives us real-valued TNT counts, but TNT can only be added in integer amounts. One immediate idea for turning the real-valued solution into an integer-valued solution is to round each TNT count, but that does not give the optimal counts in general. However, just checking the four combinations of rounding the two TNT counts (rounding each TNT count up and down) will find the optimal TNT counts in most practical cases if your basket is efficiently designed. More specifically, you can compute and check if the diagonal entries are the largest (in absolute value) in their row and column. If that condition is satisfied, then the optimal solution is guaranteed to be one of the four cases you get by rounding up or down. For more information on how this condition was derived and how to solve this problem in general if you don't meet the condition, see this document.

The most basic basket allowing 360 degree range has 4 possible explosion positions, but uses only 2 for any given shot. In the case of TNT it is easiest to align it into the corners of blocks.

Ideally the TNT should go as close to the ender pearl as possible. With this basket the pearl goes in the middle, and because of the ender pearl's collision checks with TNT, the closest the TNT can go is 0.79 blocks away from the center. Therefore the biggest block hitbox that can be used on the corners is 11 pixels (most notably flower pots, conduits, and walls with no middle column).

Lava is most commonly used to stop the explosions from destroying blocks. Water also works, but unlike lava it cannot be used in the Nether and changes the ender pearl's movement. It is common to hold up the TNT using fences under the lava because raycasts cannot hit the top part of the fences and obstruct the explosion (see Explosion#Edge cases for more about the exposure raycasts).

Each pair of TNT positions can reach only one out of the 4 quadrants of the world. With the pictured slime block layout, there is always one slime block that stays retracted and one that extends. To calculate TNT counts you need to first decide which quadrant the destination is in, and then use those two explosion positions for the rest.

The simple 4-corner basket has a major inefficiency: The two corners of TNT come from different sources. This means that, for example, shooting along a perfect diagonal uses at most half of the available TNT in the whole cannon. It would be more efficient if the total amount of TNT could be split in any ratio between the two corners. This is the concept of the "differential" basket. The name comes from the differential used in the drive of wheeled robots, specifically the "swerve" drive used commonly in FTC robotics.

In order to get the TNT in any ratio, the TNT enters the basket and is then separated using entity stack separation. This can be done using a trapdoor or fence gate activated by a pressure plate, but it's usually easier to use other TNT. Here is the required update order when using TNT:

1. All the main TNT is aligned into the exact same position.
2. Upwards or downwards acceleration TNT explodes. This is necessary so that one of the two "corners" doesn't affect the other. The main TNT needs to be given at least 8 blocks/tick of velocity (or 8.04 when accelerating upwards to counteract gravity) so that it moves out of explosion range in a single tick.
3. Sideways acceleration TNT explodes. The purpose of this is to get the first "batch" of TNT the required velocity to hit a corner. After this step the main TNT should all have above 8 blocks/tick of velocity in Y and diagonal velocity in X and Z.
4. First "batch" of main TNT ticks. It moves vertically from its starting point, then diagonally to its final position in the first "corner", then explodes there.
5. Stack separation TNT explodes. Only the second "batch" of main TNT, which hasn't ticked yet, is affected. It is given the velocity required to cancel its existing horizontal velocity and end with enough to reach the second "corner".
6. Second "batch" of main TNT ticks. It moves vertically from its starting point, then diagonally to its final position in the second "corner", then explodes there.

There are many different possible ways to encode the TNT sources to produce TNT in the correct order. For ease of wiring, it is generally good to minimize the amount of TNT that needs to switch batches.

One way to encode a differential basket is to have a "variable bit". The strategy is based off of the assumption that one corner of the basket will always have an explosion count larger or equal to the other. By default, we assume that the early corner is always the smallest. This allows us to have 2 sides to the cannon: the "simple side" that has all its TNT on the late order, and the "complex side" that has some TNT in each order.

Notice that when the amount of explosions on each corner is less than half of the total TNT count, the simple side will be entirely late TNT and the complex side will be entirely early TNT. When more TNT is needed on the late corner, we can encode with the following strategy:

• Fill the complex side with all required early TNT, which is guaranteed to be less than half of the total TNT.
• Fill the rest of the complex side completely with late TNT. This amount is also guaranteed to be less than half of the total TNT.
• Fill the remaining late TNT needed in the simple side.

Now if we need more TNT on the early corner, we can swap the entire simple side to produce late TNT and use the same strategy:

• Fill the complex side with (half the total TNT) - (required late TNT) early TNT, which is guaranteed to be less than half of the total TNT.
• Fill the rest of the complex side completely with late TNT. This amount is also guaranteed to be less than half of the total TNT.
• Fill the remaining early TNT needed in the simple side.

This scheme requires 2 additional bits of information compared to a simple basket:

• A "variable bit" which enables all disabled TNT on the complex side but with a later order.
• A "side swap bit" that toggles the order of the simple side.

One important observation is that the "side swap bit" will only be on if the "variable bit" is also on. This allows both to be represented as a single ternary number: 0 if both corners have less than half the total TNT, 1 if more TNT is needed late, and 2 if more TNT is needed early. In total this means that encoding a cannon with 2^N TNT requires 2N + 1.5 bits of information.

Here is a table comparing the functionality of each bit in the encoding between a simple basket and a differential basket:

There is still another inefficiency in the differential basket. Acceleration is most efficient along each fixed velocity direction (e.g. putting all the TNT in one corner and shooting straight along the diagonal), but it is inefficient in other directions (e.g. shooting straight along a cardinal direction requires putting half the TNT in one corner and half in the other, which covers less distance than if the TNT was all in one position). It would be better if we could position every explosion in one place and be able to change freely where that place is, which would give a circular range instead of a square range.

However, putting every TNT in the same position is also inefficient. In order to have the same precision as a differential basket, there would have to be an entire cannon of TNT just to position the explosions accurately enough. This would end up doubling the amount of total TNT, where half is used to position the explosion and the other half explodes in that position. In the circle basket we find a better compromise.

The idea is to use the differential basket technology with 2 explosion positions, but choose the 2 positions freely from a grid of possible positions. In order for the explosion efficiency to be optimal the grid needs to be as small as possible. To achieve this we can use the same TNT-based TNT separation technology from the differential basket, but with multiple side acceleration TNT. Each one needs to give the main TNT the minimum possible motion to keep the grid small.

The size of the grid does not need to be very large to approximate a circle very closely. In the differential basket, 4 possible points gave a square. Here, a 3x3 grid gives an octagon, a 5x5 grid gives a 16-gon, a 7x7 grid gives a 32-gon, a 9x9 grid gives a 48-gon, and so on (these numbers are 8 times the totient sum function). See this desmos graph for a visualization of the true shape of the range.

Once the basket is set up, the encoding is done the same way as the differential basket. However, note that for most target destinations there are multiple pairs of explosion points that can reach it. You may decide if you want to consider all possible pairs; the most efficient (least required TNT) pair is always the two points whose velocities point closest to the target, but considering the other pairs gives you a chance to get higher accuracy at the cost of TNT efficiency.

The first step is to decide which explosion points will be used for the shot. If using a basic 4-corner basket, this means choosing which quadrant the destination is in. For more complicated baskets you may need to repeat this whole calculation (steps 1-5) for multiple pairs of points to pick the best one.

The second step is to write down the velocity given by each explosion point to the pearl. The easiest way to get the velocities is to use the carpet mod to print them using /log explosions full. This will let you click on the velocities in your chat and copy them directly, skipping this whole step. If you don't have the mod, the next best thing is to use the explosion entity influence calculator:

The easiest way to convert a target velocity into explosion counts is to use a matrix multiplication. We will call the matrix that transforms explosion counts into ender pearl velocity . It is always the same for the same 2 explosion points, and is computed by just using the explosion velocities as the columns; for two explosion velocities and , the matrix is given by: Then the matrix that transforms ender pearl velocity into explosion counts is the pseudoinverse , which can be computed using a linear algebra library (it is usually called pinv; for example, pinv from the LinearAlgebra library for Julia, or numpy.linalg.pinv from the NumPy library for Python, or pinv from MATLAB). There is also a calculator below (see All in one calculator). Once the matrix is computed, you can just multiply it with the desired ender pearl velocity and it will output the TNT counts.

For example: here is the matrix for a 4-corner basket with a perfectly aligned pearl, being used to calculate the TNT counts to give the pearl velocity: From that calculation, you find that the TNT counts that get you closest to the target are 25 and 8 respectively.

{
 "title": "Ender Pearl (entity)",
 "rows": [
 {
 "field": "Acceleration, Drag, Position",
 "label": "Ticking order"
 },
 {
 "field": "0.03 ([https://en.wikipedia.org/wiki/Double-precision_floating-point_format double])",
 "label": "Gravity"
 },
 {
 "field": "0.99 ([https://en.wikipedia.org/wiki/Single-precision_floating-point_format float])",
 "label": "Drag"
 },
 {
 "field": "2.97 b/t (59.4 m/s)",
 "label": "Terminal velocity"
 },
 {
 "field": "99 blocks per b/t of initial velocity",
 "label": "Maximum travel"
 }
 ],
 "invimages": [],
 "images": []
}

There are multiple possible trajectories depending on how many ticks the pearl flies for. It is recommended to calculate the explosion counts for all of them and at the end select the one that best fits your needs (the one that gets closest to the destination, the one that arrives fastest, the one that uses the least explosions, etc).

The ender pearl's displacement refers to how far you want it to move from its starting position: .

The formula for the ender pearl's displacement after ticks starting with velocity is with d = 0.9900000095367432 and a = [0.0, -0.03, 0.0].

Therefore, you can calculate the required velocity by inverting the above formula: You should now have a value for the initial velocity for each possible tick length . See the all in one calculator to have this done automatically.

Now that you have the initial velocity required to hit the target for every possible travel time, you can feed them into the matrix from step 3 and get explosion counts for each one. You will need to round the outputs of the matrix multiplication so that they represent a discrete amount of explosions.

Due to the limit for maximum calculations on a wiki page, no more than 30 ticks of data can be shown here.

Here are a few curated examples of 360 ender pearl cannons for various game versions and basket types. There is also a playlist on YouTube with all known 360 cannon videos on the platform.