How adding a simple feature can break OTHER things in your game.
Players often wonder how devs break things. They rant and rave and say things like “this worked yesterday, why can’t they just leave the things that work alone and work on new things instead.” What they don’t understand is that is a contradictory statement. I will give you a very simple example.
In Primordiax, I decided that I wanted to keep track of the “last location” any clone (a clone being any object – an item, a player, an NPC, etc. that exists in the game world). The last location would basically be the environment that it was in last, before it came to be in its current environment. For a player, this would be the last room you were in before your current room. For an item, this would be the room it was in before it was picked up, or the PC/NPC that was holding it before it was dropping in a room. Knowing the last location of something is useful for a variety of things. For PCs/NPCs it can be useful for knowing where to send them with a retreat command/spell, or a good place to send them if they somehow get stuck. For items, it is frequently interesting to know who held an item last when you are investigating it on the ground. There are a variety of divination spells that can potentially make use of that information.
So I added this feature in and everything was wonderful.
Until all of a sudden players started having trouble stacking similar items (like resources, animal body parts, etc.) in their inventory. They were unable to stack things manually with the stack command, but they were able to stack things if they dropped them and picked them both up – letting auto stacking do the work.
Fortunately, since Primordiax is new and is primarily played by excited early adopters and very few (if any) jaded, grumpy people, nobody got freaked out about this problem. On an older game, something like this would very likely result in the complaint I mentioned at the beginning: “stacking worked fine yesterday, why did you mess with it? Work on new things rather than tinkering with stacking!!!!11!!!one!!”
But as you know from reading this, I wasn’t messing with stacking. I was actually adding a new feature that would then make a number of additional player abilities or spells possible. The problem was, when the “last_location” variable was set on items, that meant that two different stacks of an item could potentially have a different data value for that variable. One stack of ore might have a last_location of one location (the place you harvested that stack of ore), whereas another stack of ore would have a different last_location setting from wherever it was harvested. The stacking code is coded such that you cannot stack two items that have different data settings. That’s because different data (other than quantity, which is ignored) means the two stacks/items might have different quality or some other important data that you don’t want to be wiped away when it gets merged in with a similar stack.
So the problem here was that I forgot to make “last_location” an ignored type of data just like stacking ignores “quantity.” The reason it appeared to players that auto stacking was fine was because once they dropped the two items on the ground, those two items would then have the same “last_location” once they were picked up.
The moral of the story is this: it is very easy for things to get broken in totally unpredictable ways when devs are indeed working on “new stuff.” Players should try to keep that in mind. MMOs are not single player games. Their code, just like their communities, live, breathe, and grow. That means growing pains sometimes.


I love software development. Unintended consequences of seemingly unrelated changes make for interesting puzzles, and so long as you not dealing with life-or-death time pressure, they can be fun as hell to unwind.
You wouldn’t believe the sort of things I (temporarily) broke in the application I work on when I implemented a feature for digitally signing some documents that flow through our system. Suddenly all sorts of bits were failing that you never would have guessed would be connected. It was enlightening.
Yeah, you just gotta love that. If you get philosophical about it, it definitely makes you start to think about code in a somewhat biological way. The way code can affect totally unrelated, unconnected pieces of code is really quite interesting. I guess it just goes to show that there are more similarities between complex systems (whether it is a program, or actual life) than we might expect.
It’s also a good warning about tinkering, whether it’s with code, biology or other complex systems like economies. Unintended consequences can be harsh, even if you *do* spend time trying to think ahead.
fantastic issues altogether, you simply gained a new reader. What may you suggest about your put up that you simply made a few days ago? Any sure?