The Most Obscure Bug in Terraria

[00:00:00]When generating a world, have you ever  sat down and watched each pass go by?

[00:00:04]If you have... have you noticed anything? Well, the most obvious thing is probably how insanely slow generating the underground desert  is... which is by far and away the slowest pass.

[00:00:16]Relative to the rest, it seems to  take an agonizing amount of seconds while the rest take just frames to go by. However, one pass you wouldn't clock as being slow is probably "Generating jungle ruins", or  generating the Jungle Temple. Normally, these world structures are incredibly quick to generate. And if you're generating a normal world, this is true - the Jungle Temple's generation  pass is so fast you'd miss it if you blinked.

[00:00:41]But this isn't the case in Don't Dig Up worlds.  When the Jungle Temple is generated there, it hangs for a second before continuing  as normal. And it's specifically this pass - the rest of them act normally. It's quite an interesting behavior. But what's probably more interesting is why it happens, which  has absolutely nothing to do with Don't Dig Up.

[00:01:02]This might be the most obscure  fact on this entire channel.

[00:01:06]This occurs because of a broken  loop in Jungle Temple generation.

[00:01:09]In normal worlds, the Jungle Temple  will generate on any jungle grass tile, but in Don't Dig Up, since the temple spawns near  the surface, it has different generation logic.

[00:01:17]One part of this logic scans in a  10x10 tile radius to make sure it doesn't conflict with existing structure tiles. However, this scan has a variable error in it.

[00:01:27]This first loop is meant to count from the  tile ten tiles left of the candidate tile to the tile ten tiles right of the  candidate tile. Thus, it should count starting from candidate minus ten, and ends  when the counter reaches candidate plus ten.

[00:01:38]However, the loop is improperly written  such that the ending condition is when the counter reaches counter plus  ten, not candidate plus ten.

[00:01:46]Well, a number is always less than itself plus  ten, so this ends up being an infinite loop!

[00:01:52]This loop will only ever terminate when the  counter plus ten actually does an integer overflow, turning into a negative number, which  finally satisfies its loop exit condition. That takes 2.147 billion iterations... quite a lot. Luckily, the code inside this loop is also broken for a completely different reason so this loop  actually just doesn't do anything... so it's not actually that slow to run 2.147 billion times. Computers are fast enough to count 2.147 billion times pretty fast, so all this manifests as is  a slight hiccup in world generation - which is probably why it hasn't been caught  in the years since 1.4.4 came out.

[00:02:29]In all, this is a pretty short and  interesting example of a simple coding bug, and it really illustrates how the most  nefarious bugs aren't the big catastrophic ones, but instead the ones that occur silently and only  cause unintended behavior when you aren't looking.

[00:02:44]Hello! If you enjoyed this video,  please consider subscribing, as only a quarter of you are. Similar  videos are on the left and right.

[00:02:51]Either way though, thank you for watching, and  good day and good bye! See you next fortnight.