Added code to EventHookContainer.revivePlayerInLimbo() so that the
player's food level is restored upon respawning in Limbo. Apparently it
was possible for players to have death loops from starving to death in
Hardcore Limbo.
Changed the function call for playing the rift-closing sound to match
other similar calls in Minecraft - the sound should target the center of
the block. I also switched the last flag argument. It seems to determine
whether distance between the player and the source should be checked
when playing back the sound, although documentation is lacking so I
can't be sure. Other blocks that use that function use "false", while
things involving sounds that should be heard uniformly, such as
rainfall, use "true".
---
I noticed that this code runs on the client and server. Some parts
modify link data and rifts on the client side. We should really stop
this from happening as it could lead to inconsistencies.
Added support for using Stabilized Rift Signatures from dispensers under
specific conditions. Everything works except for playing the sound that
occurs when an SRS is used. Not sure why that's not working.
1. Removed several fields and functions referring to the newer rendering
code. The functions were just cluttering up the code and the fields were
consuming additional memory that was never being used for anything.
2. Updated NBT reading and writing functions to give some tags proper
names and to remove references to unused fields.
Removed the tag for riftCloseTimer because it was unnecessary alongside
the shouldClose flag. If a server reboots while a rift is closing, the
rift can start over upon reloading.
3. Renamed some fields and functions to have better names.
4. Changed the various checks for closing rifts. There were a few
redundant parts. We don't have to put calls to "this.invalidate()"
everywhere on top of explicitly removing the tile entity and destroying
its block.
5. Rewrote update timing checks. The rift spread and Enderman spawning
calls have been separated to distribute the impact of updating a rift.
Also, a flaw in the timing logic meant that the calculations for
particle offsets would only run when a rift was first created. That's
been fixed.
1. Fixed the bug where the setting that controls whether Endermen can
spawn from rifts was being ignored. It was never checked at all.
2. Cleaned up some formatting and annotations.
3. Removed call to World.removeBlockTileEntity() following a call to
World.setBlockToAir(). The latter function already handles removing the
tile entity.
1. Changed hasEffect() override since we were overriding a deprecated
version.
2. Fixed a bug where we checked if a block could be edited before
deciding whether to change the Y coordinate of the rift to be placed.
Sometimes we would place the rift in a different block. This is the
result of sticking in support for special blocks like grass and snow
without considering the impact on surrounding code. It also contradicted
comments that specifically said special blocks were ignored...
3. Cleaned up the code for checking for special blocks.
4. Fixed a bug in loading NBT data. There were no null checks on
orientation data. If a Rift Signature or Stabilized Rift Signature had
been created in a version of DD before orientations were set up, then it
cause an exception when so much as looked at in later versions of DD.
5. Partially implemented free redirects for Stabilized Rift Signatures.
The check to determine if a redirect is being done is missing.
1. Changed the crafting recipes for most DD items to use Ender Pearls
instead of Stable Fabric. The items that still use Stable Fabric are
Dimensional Doors, Golden Dimensional Doors, Rift Blades, and Stabilized
Rift Signatures. Steven had already made this change in another branch
but I'd like to push this out with several bug fixes. The SRS recipe is
different from his version - it's now just 4 Iron Ingots and a Stable
Fabric.
2. Change Stabilized Rift Signatures back to consuming Ender Pearls
instead of Stable Fabric.
Finished implementing Personal Pockets
-any pocket created from within a personal pocket retains personal
status
-exit doors cannot be used in any personal pockets
-personal status is saved with dimData
fixed a bug that let trapdoors get around locks
fixed FoR not rendering properly
-inventory and world
Changed the max stack size of ItemGoldDoor to 16 as it is for Vanilla
doors on some modpacks. Later versions of Vanilla have door stacking to
64 so this will need to change eventually.
1. Changed EventHookContainer to remove a check against
BaseItemDoor.getDoorToPlace(). The checks performed there can be done
in BaseItemDoor.tryToPlaceDoor(), which removes the need for callers to
know more internal details about how doors are handled. I moved the
checks inside.
2. Renamed vanillaDoorMapping to doorItemMapping. It now maps dim door
items to themselves to remove the need for various checks we were
performing. Updated BaseItemDoor's constructor to reflect this change.
3. Removed BaseItemDoor.getDoorToPlace() and integrated its
functionality into BaseItemDoor.tryToPlaceDoor().
4. Changed BaseItemDoor.tryToPlaceDoor() so that it simply returns false
if a given item stack cannot be used to place any doors. We don't need
to check if the item is an ItemDoor or anything like that now.
1. Cleaned up some spacing and unused imports in EventHookContainer.
Also changed an indirect reference to BaseItemDoor.trytoPlaceDoor() to a
direct reference seeing as the function is static and should be accessed
that way.
2. Renamed getDoortoItemMapping() to getDoorBlock(). The original named
had a minor capitalization mistake and implied that it would return a
mapping table or would associate doors to items. The function actually
associates items to door blocks.
1. Stopped Monoliths from teleporting players while in Limbo. This was a
serious issue on some modpacks if players got unlucky.
2. Decreased the required Monolith aggro level to start spawning
particles around a target player. The required level was so high,
combined with the current Monolith speed, that players would hardly see
the particles.
3. Disabled Monolith sounds in Limbo. Some of the sounds were really
annoying in Limbo. Usually they only get to play for a moment before a
player is teleported, but since no teleports occur in Limbo and the area
is full of Monoliths, the constant noise is aggravating. It would also
drown out the background music.
* Fixed a mistake in the crafting recipe for Golden Dim Doors
* Removed static import of fields from mod_pocketDim. There were already
qualified references to those fields in some areas. We should be
consistent.
* Fixed issue with Monoliths detecting players through walls
* Changed aggro values from bytes to shorts
* Fixed aggro updates so that aggro levels can decrease
* Fixed upper bound on aggro clamping
* Added client/server-side checks to a few functions to save on
performing pointless checks, such as making calculations for spawning
particles on the server
Removed lots of obsolete and unused code from Monoliths. The code is
subdivided more clearly now. The aggro level is sent over a data watcher
instead of sending the texture state.
Keybounce noticed that he was having a persistent item ID conflict with
DD's Golden Doors - the normal doors not the dimensional variant. I
discovered that we have been assigning them the same ID as the Golden
Door block ever since they were first introduced 7 months ago. It didn't
break immediately since Forge adds +256 to item IDs.
* Changed saving code to create backups by moving existing files rather
than creating copies and deleting the originals.
* Removed final call to PocketManager.save() in PocketManager.unload().
Since we no longer check if the caller is the client or server and
unload() must be called from both, this prevents clients from trying to
save pocket data locally. A final save() call wasn't needed anyway.
Added a flag to NewDimData so that we can avoid writing dimensions to
disk if they haven't been modified. They're still rewritten when the
server shuts down.
Made saving a bit more robust, now we only delete ones that where not
modified. Also overhauled door placement, its all handled by the
eventHandler now.
* Changed DDTeleporter to stop us from generating exits to Witchery's
Spirit World - this would cause people to lose their items upon leaving
the dimension.
* Changed GatewayGenerator to stop us from generating gateways or rift
clusters in the Spirit World
Changed FillContainersOperation so that empty dispensers are not filled
with a stack of arrows on import. Just in case someone needs to use
empty dispensers in their design. As far as I can remember, this won't
affect any of our dungeons - arrow traps are rare. The only dungeon that
I can remember is one by Balgor and it was exported with all of its
dispensers loaded.
* Added a small treasure room that opens when the puzzle is solved and
made the exits in the corners slightly more apparent by placing redstone
lamps.
* Tweaked the redstone a little to correct for a brief signal cutoff.
* Tried to add fireworks that would shoot out when the puzzle was
solved, but it was too hard to secure them against theft while also
getting consistent explosions.
Updated the dungeon pistonFallRuins so that it causes less extreme lag
by slowing down and spacing out the timing for the piston traps. Also
reinforced the dungeon against tampering and added lava inside each
piston drop.
XombyCraft has been kind enough to research which provider and biome IDs
are used by major mods. He found some ranges of free IDs and suggested
changing our defaults to sidestep conflicts with Biomes o' Plenty.
Fixed a nasty crash to desktop. It happens when ChickenChunks is
installed and a new world is generated with HardcoreLimboEnabled = true.
It appears that ChickenChunks forces a chunk to generate in Limbo if
LimboProvider.canRespawnHere() = true, which is the case if hardcore
Limbo is enabled. Our Monolith and gateway generation code runs as a
tick handler instead of through standard world gen calls. I believe
Limbo is unloaded immediately after the chunks are generated because no
players are around. That would cause DimensionManager to return null for
Limbo because it's not loaded, which would crash our code. We probably
dealt with this for Monoliths by adding a check. Now it happened again
because we didn't take precautions while calling the gateway generation
method. I've added code to forcefully load Limbo if it's not loaded.
Changed the condition on LimboProvider.canRespawnHere() so that players
can respawn in Limbo even if LimboEnabled is false. LimboEnabled only
controls whether players are sent to Limbo when they die in a pocket. It
does not prevent players from ending up in Limbo because of Monoliths.
If Hardcore Limbo is enabled, it stands to reason that people should be
respawning in Limbo anyway.
After finally getting the dungeons to load, I've determined that only
half of the rooms should be included. The three remaining rooms should
definitely stay. That's not much for a pack so I'm going to make some
modifications to the schematics and include them as part of Ruins.
* Fixed Limbo gateways. I accidentally broke them while overhauling
gateways in general.
* Changed references to BaseItemDoor.placeDoorBlock() to use
ItemDoor.placeDoorBlock() instead. We should refer to the original class
that implements the function.
* Set up the necessary code in DungeonHelper so that Balgor is
registered along with the other bundled packs.
* Improved the code for registering bundled packs to reduce the number
of paths we need to hardcode and to crash DD if a pack fails to load. A
crash would be inevitable no matter what since bundled packs are
integral to DD.
* Corrected an invalid generation rule for Balgor. It's set to select
random dungeons infinitely for now. I'll add an exit room later and
change the rule to force an exit. Balgor is still unusable until its
schematics get proper doors.
* Fixed PocketBuilder to actually check the results of validating
schematics before we try to build them. This was causing cryptic error
messages when flawed schematics were loaded (e.g. rooms without proper
doors) and could have caused serious problems during dungeon
regeneration. Don't ignore validation!
* Split off schematic-related functionality into BaseSchematicGateway.
* Moved the default implementations of many methods to the base classes
because having a bunch of duplicate stubs all over the place was a
waste.
* Removed methods that were redundant or weren't being used for
anything.
* Added support for importing schematics while ignoring air blocks
through IBlockSetter - now our gateways are copied in without air by
default.
* Fixed bugs that would have prevented the sandstone gateway from
generating.
* Removed the code in generate() that would cause dungeon
pre-generation. We should solve this by attaching data to links instead
and it's not a feature that we're even using right now (everything uses
the default pack).
* Fully documented our functions - it's so beautiful...
Changed dd-rift and dd-random so that rifts are only placed after a
dungeon is generated successfully. We also delete the link if generation
fails to clean up after ourselves. Also changed
PocketBuilder.generateSelectedDungeonPocket() so that its checks are
stricter and we validate dungeons before allocating a dimension.
This resolves one of our old issues: "Rearrange workflow in dd-rift to
prevent rifts from being created if no dungeon gets loaded and to
prevent dimension registration if the dimension cannot be populated"
Changed the code for dungeon selection in various classes so that rather
than allocating and passing around the dimension where the dungeon will
be generated, we instead pass around the parent dimension. This
simplifies our code and moves us toward avoiding stray dims when dungeon
selection fails and to solving the dungeon pre-generation problem with
gateways.
Added a new setting to dungeon pack configs called
"DuplicateSearchLevels", which allows us to configure how many levels up
of the dungeon tree should be checked to avoid duplicating rooms used in
that subtree. In other words, it lets us avoid repeating rooms used in
neighboring branches of the dungeon. The setting has been added but it's
not fully supported yet - some additional code is needed in
DungeonHelper and it's not trivial to implement. I took a break because
doing it wrong could break dungeon selection.
Added a setting to DDProperties for controlling the max distance that
players can be moved randomly when they're sent to Limbo. We previously
had a setting for the same except for leaving Limbo. Cleaned up some of
the related code a little. Added another setting for the chance of rifts
dropping World Thread on block destruction. Also fixed a potential NPE
in EventHookContainer that could arise theoretically arise if a
non-Vanilla door was attached to a rift.
Cleaned up the code for placing Vanilla doors on rifts in
EventHookContainer. Unfortunately, there's a section that I don't
understand and that I feel has a bug. Remember that comments are very
helpful.
The following small change deals with a strange background-music-related
crash. Wasn't this issue fixed for Jaitsu and Aether II? I'm not sure
what's the cause but I've added a check to prevent the NPE. Please deal
with this most robustly in the future.
Removed duplicate code from ItemRiftBlade. It was code that duplicated
the functionality of ItemSword since ItemRiftBlade didn't extend
ItemSword originally. Also updated the tooltip text to remove mentions
of the old door-rotating ability. That's not provided anymore since
doors are easily broken and replaced now. Extended teleport range
slightly.
Added a check so that Dimensional Doors crashes if another registers our
provider IDs. This will show people that something needs fixing instead
of us risking strange bugs.
Set loot chests to generate 6 stacks of items instead of 5 stacks.
Increased the maximum amount of World Thread per stack from 8 to 12
threads. Increased the chance of encountering a grave chest to 1 in 6
instead of 1 in 7.
Added a configuration option for toggling whether players can teleport
out of Limbo by walking over Eternal Fabric. This became viable after
Rift Gateways began generating in Limbo again. Keybounce has expressed
an interest in using option to deal with the issue of players returning
home since his Overworld won't have gateways.
Changed dungeon exits so that they have a minimum 15% chance of exiting
to the Overworld if a dungeon's root dimension isn't the Overworld. Also
made a minor change to the existing special case for the Nether - the
minimum 20% chance only applies if the root dimension isn't the Nether.
Added a configuration option for adjusting the number of World Threads
needed to create one Stable Fabric. A few users have asked for this to
be available. The default setting is our usual 8 thread for each fabric.
Also overhauled our recipes to remove blank item slots, allowing them to
be crafted on any line of the grid, as long as all the items are aligned
properly.
Made a small correction to the condition on max ancestors. Also
thoroughly tested this code to ensure that it really does limit rift
spread. Currently, 2 initial rifts will cause 4 more rifts to be created
eventually.
Switched rifts over to using link.childCount() to track spread instead
of the hasGrownRifts flag in the tile entity. The flag had the flaw that
if the rift was replaced by a block, the flag would reset and the rift
could spread again. I think I remember this being intended as punishment
for messing with rifts but it's a problem when combined with World
Thread farming.
Fixed the issue of rifts spreading through walls. We tried using
raytracing but rifts would always "leak" out of unbreakable enclosures.
With this latest change, rifts spread with the same logic that
determines which blocks are reachable to them.
Added a per-save config file called DimDoorsWorld.cfg. Its corresponding
class is DDWorldProperties. This class supports whitelisting and
blacklisting dimensions for Rift Cluster and Rift Gateway generation.
Note that our ban against generating gateways in the Nether and The End
still applies regardless of those settings. The new config file is
loaded before the server starts initializing terrain. Also moved
DDProperties to another package alongside DDWorldProperties - that
required updating references in most of the mod's files.
Added SK-RaceTheLight to our schematics. Changed the weights on
Cere-FloatingAltar and Cere-PuzzleWall to 75 (previously 100). Fixed
what appears to be a mistake pasted into ruins.txt and also updated it
for the latest dungeons.
Fixed the way textures are applied so that doors from our mod can appear
as double doors. Renamed door textures to be consistent with Minecraft
door textures. Got rid of a few obsolete textures. Unfortunately,
something broke with door blocks updating. I need to fix that in the
next commit.
Improved some of our door code by giving some of our variables real
names. Also found a hack in BaseDimDoor.isDropped() and a strange
comment that said "I have no idea, but sometimes this is returned as the
blockID instead of metadata." I finally figured out that due to some
random mistake introduced in another function, idDropped() sometimes
received a block ID instead of metadata, which is what that comment
referred to. I fixed the cause and removed the hack.
Shifted the duplicate code from our biome classes into a single parent
class. Also added checks so that Minecraft crashes if a biome ID
conflict occurs. This is to put an end to the recent streak of posts on
our MCF thread about people experiencing issues because DD and BoP have
conflicts out of the box.
I copied two functions from CommandBase into DDCommandBase because their
absence is breaking our builds on Technic and Dryware Jenkins. I have no
idea why that's happening. My copy of MC's source code has those
functions in CommandBase and my code compiles without a problem.
Dropped support for Minecraft's structure generation flag because
several other mods ignore it and supporting it can give the appearance
that DD isn't working properly. We already have settings for disabling
gateways in our config file.
Fixed rotations for hopper and droppers. Hoppers were failing because
powered hoppers have different metadata. Droppers were just missing from
the list of oriented blocks. Fixed the wooden buttons on Cerevisiae's
altar room and added her puzzle room once hoppers were working reliably.
Made some minor changes to the way that we register commands with
Minecraft. Also changed the way that we generate onCommandUsage()
strings so that the style of our outputs is consistent with that of
Minecraft and Forge commands. It seems the way the messages were
generated changed for MC 1.6. Finally, removed compareTo() from
DDCommandBase since it was completely unnecessary (CommandBase already
does the same) and casting objects to CommandBase was causing errors
with some Chicken Bones commands that directly implemented ICommand.
Fixed the issue with clients not receiving notifications of gateways
being built into the world because we were modifying chunk data
directly. Our schematic classes now support building through World
instead of directly writing to the underlying chunks. Also fixed an NPE
that was introduced last night when I changed which line
GatewayGenerator was initialized on in mod_pocketDim.
Fixed an NPE that would occur because mod_pocketDim.deathTracker was set
to null before the last onWorldSave event was triggered when a server
was shutting down.
There is 5% chance that grave chests will contain the head of a random
player that has died in a pocket dimension; there is a 20% chance of it
being a special head. Also moved Ghast Tears to grave chests and removed
Eyes of Enders as loot. Also made FoR loot more rare but increased the
amount given out so that the average amount picked up should be the same
as before. World Thread is slightly less common in response to being
easier to farm from rifts.
Added code to save DeathTracker data when then Overworld saves, but only
if it's been modified since the last time it was saved. Also changed how
we handle player deaths in pocket dimensions. Now we have two death
handlers. There is a high-priority one that sends players to Limbo only
when Limbo preserves their inventories. The other is a low-priority
handler that sends players to Limbo only when inventory preservation is
disabled. This gives players a chance to keep their inventories if
another mod would have revived them without that penalty.
Added DeathTracker - a class for tracking the deaths of players on the
server while in pocket dimensions. It'll be used for generating skulls
for grave chests. Also removed PlayerTracker since it wasn't being used
for anything at all. I'm guessing it was supposed to be used for
something later. We can restore it if it's ever needed.
Cleaned up the code for initializing GatewayGenerator. We had some
static fields that didn't need to be static and we could just initialize
gateways from the class's constructor.
Moved a little of the regeneration code to BlockRift to reduce duplicate
code. Changed RiftRegenerator to iterate over loaded worlds instead of
all worlds. Removed forced rift generation call in
EventHookContainer.onWorldLoad() - I feel it would have minimal
benefits. Rifts now drop World Thread upon regeneration. Generally
cleaned up the code in FastRiftRegenerator and RiftRegenerator.
Removed code related to a correction factor that would compensate for
gateway generation failing a lot more frequently in the Nether. We don't
use that approach in the Nether anymore.
Added config settings for the chance of generating a Rift Gateway in a
Nether Fortress. Also made it so that DD does not override Nether
Fortress generation if fortress gateways are disabled in some way.
Changed rifts to consider block blast resistance instead of block
hardness. Some mods offer defensive blocks that stop explosions but have
low hardness. This addresses that issue. The minimum resistance allows
obsidian to resist rifts.
Fixed the code for retrieving textures for ItemRiftBlade,
ItemRiftSignature, and ItemRiftRemover. Renamed Rift Blade item texture
again due to capitalization issues. Replaced World Thread texture with a
dark variant of MC's String - we can switch to another texture later.
Cleaned up the code in FastRiftRegenerator - mostly spacing, but also
removed a pointless null check. It wouldn't matter because the reference
was being accessed before it was checked and it should be impossible for
it to be null.
Updated our code to stop Fabric of Reality platforms from generating
under exits all the time. Now they generate only when the supporting
blocks are replaceable (in which case they're replaced by FoR) or when
they're not opaque solids or have tile entities (then FoR generates on
top). The exit search algorithm treats replaceable non-liquid blocks as
air, so an attempt is made to build against the ground and not on top of
replaceable blocks. The area around the door is cleared of blocks to
avoid killing the player with lingering replaceable blocks that might be
harmful, like poison ivy.
Fixed a bug in BaseGateway that would cause it to still crash servers
during world generation. The import filters must be applied before
searching for doors because GatewayBlockFilter uses Forge-provided block
IDs and not the standard export values. Also fixed a comment in
yCoordHelper that cut off strangely.
Added chunk.setChunkModified() to other classes that were missing it. We
have several copies of setBlockDirectly() spread around that needed
updating. Also made pockets use FoR instead of glowstone. =P
Updated DDTeleporter to have a fixed minimum chance of sending the
player to the Nether when using a dungeon exit. This also allows players
to reach the Nether without ever having been there before using a Nether
portal - that was previously impossible since DD would not "know" that
the Nether existed. Also cleaned up the code a bit and possibly fixed a
bug that would cause players to get teleported into walls.
Added a line in our config file for setting the block ID of Corium. Even
though it's only temporary code that's going to be removed later, people
need that to run our dev builds properly.
Changed Rift Blade recipe to use Stable Fabric and a Blaze Rod. Changed
its base material from Gold to Diamond, which increases attack power and
decreases enchantability a little.
1. Made World Thread available as dungeon loot
2. Removed useless config options for loot that doesn't appear anymore
3. Tweaked some config names and variable names for consistency
Gateway is generating, finally, but it has some... issues. Inquire
within.
Just generate a new world, and use an unstable door to warp to the first
that gens.
--Changed BlockRift to use ITileEntityProvider instead of BlockContainer
--Reorganized some of the code in TileEntityRift to improve performance
and readability
Cleaned up the code in TileEntityRift. Fixed up some spacing and changed
as many functions and fields to private as possible. Added a performance
improvement by doing the random roll for Enderman spawning before
searching for nearby Endermen.
Changed rifts to using world.destroyBlock() instead of
world.setBlockToAir(). That has the advantage of causing block
destruction animations and sound effects instead of blocks vanishing
silently.
Changed MazeDesigner to prune out some unnecessary doorways at random by
removing edges from the room graph. Previous mazes allowed all side
paths to exist, which resulted in a kind of circular layout. Although
that was disorienting to people at first, if you realized it was a
circle, it became simple to navigate through the maze. This update makes
branching paths more common.
Doorways are now placed in different ways, depending on the dimensions
of the walls that they're on. This includes that large walls get two
doorways connecting to the same room.
Fixed a bug in MazeDesigner that would connect some rooms with duplicate
doorways. The problem was in how intersections were being tracked to
improve the efficiency of adjacency checks.
Adjusted the size of mazes slightly to reign in huge rooms. If the
problem persists, we can consider other options such as dropping dungeon
sizes a little more, increasing the number of splits, or biasing the
split plane selection toward the middle of the range.
Added code to minimize the number of doorways that involve dropping
through the floor. Added a DisjointSet class as part of the
implementation. I also split the maze construction process into two
classes (MazeDesigner and MazeBuilder) to make it clearer.
Deleted old function for removing random rooms. Fixed the occasional NPE
described in my previous commit - deferred the removal of nodes from the
graph until after iterating over their collection. Added conditions for
removing maze sections that are too small to be useful.
Completed the second step of maze generation. In this step, a graph is
built that describes which rooms can be connected to each other by
doorways. A maze is created by removing nodes (rooms) from the graph.
The algorithm is incomplete, but it already produces interesting mazes
comparable to DD's hand-made mazes.
A few details for the future:
1. Doorways are currently carved into walls at default locations. This
is just for testing and placement should be improved later. Some
doorways should be removed and redundant doorways should be possible.
2. The size of a section should be assessed and the section should be
discarded if it has too few rooms.
3. An NPE occurs every so often when a maze is generated. It's possible
that it happens because of removing a node from the graph that is
coincidentally the current node for LinkedList's iterator. The solution
would be to add nodes to a list and defer removals until after the
iteration is done.
Made some progress on the second step of our maze generation algorithm:
building an adjacency graph for setting up doorways later. Renamed the
SpatialNode class to PartitionNode to better represent its role.
Made some changes to maze generation to prune out random rooms from the
structure. This doesn't look as nice as I'd hoped, so I'm going to try
some other approaches.
Added classes for generating maze dungeons. At the moment, the dungeons
are generated in place of our pocket dimensions to make testing easy.
We'll need to restore pocket generation later and integrate the mazes
into the dungeon packs later. Currently, the structures are very
incomplete (they don't even have doorways), but this is only the first
step.
Changed our loot generation. Instead of relying on Minecraft's built-in
loot categories, we now have our own static loot category. There are two
types of chests now. Regular chests contain randomly-picked coal, iron,
gold, diamonds, emeralds, quartz, enchanted books, and golden apples
(very rare). We also have a function for filling out "grave chests",
which occur in 1 out of every 7 chests. Those contain rotten flesh,
bones, and some armor pieces and equipment that are assigned random
damage values and occasionally also get level 1 enchantments. Small
changes were made to various files to incorporate this update.