Completed the code in yCoordHelper for choosing a point to drop the
player when using a Transdimensional Trapdoor. Made changes to
DDTeleporter so that the player can be dropped at the specific point we
want. This needs further testing, though, since I'm not completely sure
it's working right.
Cleaned up obsolete code in PocketProvider and fixed the assignment of
hasNoSky so that it actually applies. Also overloaded getActualHeight()
so that we return 256 despite hasNoSky = true - the default MC behavior
is that we would return 128 in that case. Also undid a previous change
to EventHookContainer - players that die in pockets will respawn in
Limbo, again.
Renamed IDimDoor.placeDimDoor() to placeLink(), since that's what it's
actually being used for in our doors. Saying it places the door itself
is confusing.
Made a minor change to DDTeleporter - added a flag so that we can
specify that entities must be teleported to the destination without
trying to shift them around based on destination orientation. This is
important for the trapdoor, since otherwise entities might get shoved
into walls. Also cleaned up some code in DDTeleporter. It's much more
readable now. These changes are in preparation for completing Trans
Trapdoor destination selection.
Merged together the different changes we had made to Transdimensional
Trapdoors. Cleaned up the rendering and tile entity code a bit, it
should be a little more understandable now.
Partially completed the code for unsafe exits (used for trapdoors) so
that they drop players into air pockets. It's not complete yet, but I
want to merge in other changes before continuing.
Improved our code for checking whether an entity in contact with a door
should be teleported. Now the check works better, works for Minecarts,
and is more readable. It also ignores particle effect entities.
Modifed the RiftFX classes so that their particles have noClip = true.
This avoids rifts spamming the collision events of other blocks,
including dimensional doors, and it should improve the performance of DD
a little.
Got the Transdimensional Trapdoor working again. Renamed the file to
TransTrapdoor and trimmed off unnecessary code - BlockTrapDoor
implements a lot of the necessary logic. Implemented IDimDoor for
clarity.
Updated BlockRotator to check if a block is an instance of DoorBlock
instead of checking for BaseDimDoor - since we changed BaseDimDoor to
derive from DoorBlock, the latter check is no longer needed.
Added a condition preventing rift clusters and gateways from generating
in The End. It's not really useful to do that right now and could
actually cause some annoying side-effects.
Fixed the regression bug that caused some of our doors to get placed in
the wrong direction. Changing doors to inherit from BaseDimDoor caused
BlockRotator to assume they weren't dimensional doors because it used
"instanceof DimensionalDoor" to check. Thanks for figuring it out,
Steven! ^_^
Also made a minor change to dungeon generation. We now check the game
rule doMobSpawning and don't spawn Monoliths from DungeonSchematic if
the value is false. This is useful for testing without Monoliths around.
We still do work to remove the portal frame blocks even if the mobs
aren't spawned.
Removed the rift creation code from the Rift Blade and removed unused
settings from DDProperties. Specifically, the rift creation flag for the
Rift Blade, since that's getting removed, and the RiftSpreadModified,
which hasn't been referenced for a while.
I also cleaned up the code in Rift Blade slightly. Its special functions
worked during testing but blocking did not. I'm not sure why at the
moment.
As part of the rewrite, I'd removed code related to replacing the
sandstone markers under dungeon exit doors, so the markers weren't being
replaced. Now that's working again.
Completed exit door code. Also fixed noise calculation for dungeon door
destinations - we were attempting to use pack depth in the calculation
before it had been initialized.
Fixed an issue with DDLoot where we couldn't distinguish between items
with the same ID but different subtypes while merging loot categories.
For instance, we could not include two different colors of dye in our
loot because their item IDs matched. We can now tell them apart properly
and include both items.
Changed EventHookContainer.LivingDeathEvent() to use the player's max
health instead of a fixed health value. No magic numbers! Also cleaned
up the code a little.
Deleted PlayerRespawnTracker and removed all references to it - we
weren't going to use it anymore anyway. Renamed IDDoorLogic to IDimDoor
- abbreviating the "Dim" as D next to the standard I for Interface is
confusing. Renamed DDoorBase to BaseDimDoor and made it into an abstract
class - that's effectively what it was supposed to be. We should be
declaring methods as abstract rather than using empty ones. I renamed
the class because the convention for naming abstract classes is to start
the name with Base. Cleaned up code in other files.
Added code so that exit doors will search for a destination and place a
platform for the player on the other side. However, the search function
only searches upward, not downward. I'd like to discuss some details
about this before completing the implementation:
1. How should the search work?
2. What should be the likelihood of a dungeon exit leading to a
different root dimension than the dungeon's actual root?
I've tested the exits and they're working well.
Added functions for generating destinations for some link types that we
hadn't included yet - player-made exits, trapdoors, and dungeon exits.
The player-made and dungeon exits still don't generate anything, but
there's a single function where we can write up the code:
DDTeleporter.generateSafeExit(). Also added some simple code for listing
root dimensions in PocketManager. None of this has been tested yet!
Cleaned up our code related to initializing dimensions. Removed
redundant instances of that code and instead created a function:
PocketManager.loadDimension() - to centralize all uses of that logic.
Added LinkTypes.REVERSE to represent links leading back out of pockets
through their entrances. That distinction might prove critical in the
future when we support resetting dungeons.
Added code so that the links for Unstable Doors are handled properly by
DDTeleporter. Hurray! Also cleaned up some unused imports in the
BiomeGen classes and removed the RANDOM_DUNGEON link type - it was meant
for the dd-rift command but there is no need for it anymore.
Moved DDTeleporter to the mod_pocketDim.core package. It seemed
reasonable given that DDTeleporter is closely tied to how Dimensional
Doors works. It controls the most critical feature for all items -
teleportation - and handles routing requests to initialize link
destinations.
Made minor changes to ItemRiftBlade to clarify our code. Had to update
mod_pocketDim to use ItemRiftBlade's new constructor after changing it
slightly.
Changed calls to canPlayerEdit() to pass hit.sideHit data with the
request. Also renamed several variables to make the code clearer.
Removed a custom implementation of the ray tracing call in BaseItemDoor
- we can use the built-in call from Minecraft there.
Made minor changes to LinkTypes for clarity. Removed removeRift() from
PocketManager since it wasn't used by anything and because it shouldn't
contain rift removal code anyway.
Fixed Rift Signatures and Stabilized Rift Signatures. A few unexpected
MC-related issues were preventing them from working properly. Also fixed
a typo that caused us to place rift blocks at the wrong coordinates with
respect to the rift sig endpoints. Autocorrected the indentation on both
source files for aesthetics.
Fixed how the door in a pocket is placed so that it doesn't break and so
that it's placed facing into the pocket. Also added code to make that
door link back to the parent dimension - forgot that before!
Fixed a similar bug in DDTeleporter and PocketBuilder that caused things
to be oriented wrong. Specifically, teleporting would orient the player
wrong relative to the destination door and pockets would be oriented
wrong relative to their parents. Teleporting works properly now.
1. Fixed mistakes in PocketBuilder that would cause dungeons to be
initialized as non-dungeon pockets. This restored Monolith spawning
around dungeons.
2. Fixed a bug in DungeonSchematic - returning links through entry doors
should work now.
3. Made minor changes to DungeonSchematic for clarity
Fixed the issue with integrated servers causing circular updates between
the combined server and client. We now check on the client side whether
the connection we're receiving data from is a memory connection (which
is presumably only used by integrated servers). If so, the client
ignores any incoming packets. We don't just disable update events
altogether because LAN games will require updating remote clients.
Also fixed a bug in PocketManager.unload() - we weren't setting isLoaded
to false after unloading everything and unregisterPockets() had to be
called before setting dimensionData to null.
Fixed more bugs. Now it's possible to generate a world without crashing.
Unfortunately, it's clear that there is a packet-sending loop going on.
I'll have to add a check to prevent integrated servers from spamming
themselves.
Finished implementing all the packet handling code. It could be improved
in the future to compress the initial packet sent to clients. With this,
the code is complete enough to run! Commands have not been fixed yet but
that will come in the future.
Threw out the complicated architecture that I'd made for synchronizing
server and client data perfectly. Instead, we now send just enough data
to the client and the resulting code is simpler. Some of the client-side
code is also done so all packet handling should be finished soon.
Continued building a system for transferring the complete internal
states of our dimensions from the server to the client. However, Steven
suggested that clients only need minimal data to operate properly, as
opposed to the server. My motivation for this more complicated system
was the concern that minimal information wouldn't be enough. I'm going
to commit my progress, then tear it down and write a much simpler
version.
Moved the DimLink code out of NewDimData in order to reduce clutter
inside that class and made it a separate class, except for functions
that should only be available for NewDimData. Deleted IDimLink and
changed all references to it to use DimLink instead. DimLink is now an
abstract class, which achieves the same encapsulation and protection we
had before by having DimLink implement IDimLink from within NewDimData.
NewDimData has a new class inside, InnerDimLink, which provides it
access to special functions that would be dangerous to expose. This is
the same mechanism used to protect NewDimData's dangerous functions.
These changes are in preparation for adding more code for packet
handling.
Started rewriting our packet handling code. Deleted PacketHandler in
favor of using sided (Server-, Client-) packet handlers to make it
easier to follow what's going on in our code. Added some event-based
handling of updates which greatly simplified signaling that data needs
to be sent, but it's not completely done yet.
Modified how links are created so that the caller must specify a link
type when the link is created, rather than setting it later. This was
done to avoid having to send two link data packets following the way
links would be handled logically. Turns out this was good idea overall
for ensuring link integrity, because there was one case where I forgot
to set the link type after creating the link.
Fixed the code in DDTeleporter and made minor changes to other classes
that depended on those fixes. Ensured that PocketManager's load, save,
and unload methods are called appropriately and rewrote some of their
code. Made various changes in other classes (e.g. EventHookContainer,
PlayerRespawnTracker) to pass them references to DDProperties through
their constructors instead of having them rely on
DDProperties.instance() - this is a better programming practice in the
long run.
Renamed initialization methods in mod_pocketDim to make it clear that
they're called on events. Commented out command registration in
mod_pocketDim so that we can test DD as soon as PacketHandler is fixed,
without worrying about fixing the command classes.
Fixed the code in ItemLinkSignature and ItemStabilizedRiftSignature.
Removed obsolete code from PocketManager - we don't need to worry about
storing link keys anymore. All the data is stored in NBT, which means no
more generating unique keys or worrying about saving and loading them.
Moved tile entity classes to a separate package. Renamed some block
classes to match their in-game names (e.g. ChaosDoor -> UnstableDoor).
Moved TransientDoor to the blocks package. Cleaned up a little bit of
the code and automatically updated references to the classes that were
modified.
More cleaning up errors and code. There were a lot of things that needed
simplifying. Rather than fix the 3 or 5 copies of the same function
throughout the code, I made an effort to use the same function and
delete its copies.
Created the BaseItemDoor class to hold all the basic door item methods
that don't vary between types. That helped cut down on fixing things.
Also renamed the door item classes to match their in-game names.
There is still a ton of duplicate code out there.
Continued fixing things across various classes to make them work with
our new core classes. I've also cleaned up indentation and random code
snippets along the way.
1. Changed DungeonSchematic to use an external instance of Random rather
than initializing its own.
2. Created the Pair class, a strongly-typed tuple that was needed in
PocketBuilder.
3. Added a missing calculation in NewDimData for setting the packDepth
field during dungeon initialization.
4. Finished code missing in PocketBuilder. Changes listed above were
needed for this.
Replaced several core classes from DD with new classes to enforce
integrity checks. Rewriting everything that depended on those classes is
a massive undertaking but it should simplify our code and prevent the
many bugs we've seen lately. The rewrite isn't done yet, just committing
my progress so far.
Fixed the two blocks sticking out in the multilevel maze that made a
staircase unusable. Put a floor in simpleDropHall so it's actually
usable rather than killing the player.
DDLoot: Implemented a custom version of MC's generateChestContents() for
our own chests. It avoids two notable bugs that affect MC's version.
FillContainersOperation: Changed code to use
DDLoot.generateChestContents()
SchematicLoader: Fixed a bug in the way we calculated a seed for
selecting our dungeons that would cause certain seeds to dominate all
the others. Under certain circumstances, the function would only return
-1. That would make our dungeon selection severely biased. That was
resolved and the code was specifically tuned for seeding Java's Random
even for doors with nearly identical positions. The result was an
apparent major improvement in the randomness of dungeons.
ruins\rules.txt: Changed the dungeon generation rules to precisely match
the complicated scheme we had before. We're still using simple rules to
choose dungeons - I used a program to derive the effective distribution
of dungeon types that the old code would produce and converted it into
the current rule system.
Created NewLinkData and replaced references to the original LinkData.
Moved it to the mod_pocketDim.core package. Added Point4D, an immutable
point type for 3D integer coordinates with an added dimension ID.
Added code so that the mod loads dungeon packs stored in the custom
dungeons folder. Changed the code for loading bundled dungeons so that
they're loaded as dungeon packs. This means dungeon packs are now fully
integrated into the mod. The changes were tested and seem to be working
perfectly.
1. Integrated support for dungeon pack config options into the code
(i.e. we actually DO what the settings specify)
2. Added random transitions from one dungeon type to another. Dungeons
might also begin with a non-default pack.
3. Fixed a config reading bug that caused settings to be ignored and
some invalid settings wouldn't trigger exceptions. Also fixed other
dungeon pack bugs.
Added code for parsing dungeon pack config files. The settings for our
built-in dungeons are now read from a file instead of being hardcoded.
One or two settings aren't being accessed yet and we still don't search
for other dungeon packs in the custom dungeon folder. That'll come in
another commit.
Made some changes to EventHookContainer.onWorldLoad() to remove
redundant code that encouraged bugs. Unfortunately, a lot of
link-related code needs to be rewritten to get rid of bugs, so that'll
come after dungeon packs are completed.
Changed how Random is initialized in SchematicLoader to prevent issues
with dim doors in the same chunks leading to the same dungeon. The
selection seems much more varied now. Also changed the hardcoded config
for the default dungeon chains to the one we'll be using later (from a
file). For testing purposes.
Decreased the default chance of a gateway generating. This won't affect
users unless they clear their config files. The decision is based on
user feedback and recent experiments on how common gateways could be.
Modified RiftGenerator to correct for the rarity of Rift Gateways in the
Nether. Our config settings allow us to set the probability that we will
attempt to generate a gateway in a given chunk. However, that doesn't
guarantee that a gateway will generate.
I collected a lot of data and determined that generation succeeds in the
Nether only about 15% of the time. That's compared to 30% in the
Overworld when counting oceans (which always fail) and about 75%
(sometimes higher) when traveling mainly on land.
RiftGenerator now corrects for this by multiplying the chance of
attempting to generate gateways in the Nether by 4. Gateways in the
Nether are still relatively rare and hard to find, but you'll
occasionally come across them now. Also reorganized the code a little
for clarify.
Completed a basic version of configurable dungeon chains. Almost all of
the final funcionality is present. However, the configuration is
hardcoded at the moment, not read from a file. This was done for testing
purposes. I'll add reading from config files soon.
Dungeon packs are partially implemented. Built-in and custom dungeons
are currently thrown into the default pack, Ruins. The next step is to
generalize the dungeon registration code in DungeonHelper so that we can
detect dungeon packs, read their config files, and register dungeons
with their corresponding pack. dd-export will need to support packs as
well. dd-rift will have issues dealing with duplicate dungeon names
across packs, but this isn't a major concern and can be dealt with in
the long term.
Completed enough of the implementation and integration to compile DD.
Some portions of the code are only for testing and will be removed
later. The configuration for default dungeons is hardcoded - we can
parse config files once we're certain that dungeon chains work. At the
moment, dungeons generate but it doesn't seem like the rules we set are
being followed properly.
Renamed OptimizedRule to DungeonChainRule, and renamed the old
DungeonChainRule to DungeonChainRuleDefinition, to match the role of
each class better. Added some hax to DungeonGenerator to get packs
integrated - the implementation will be much cleaner once the new save
format is done.
Started implementing our support for dungeon packs. The code is not
usable yet and the mod is not functional at this stage. A few additional
changes should make it testable. A significant obstacle to implementing
dungeon packs easily is that DungeonGenerator doesn't have some
necessary information and shouldn't be modified. Even if it is modified,
old serialized instances wouldn't have the new fields initialized. I'm
having to create workarounds until we implement the new save format.
DungeonPack handles all of the logic of selecting a dungeon and
verifying whether its type is valid. It relies on DungeonChainRule and
OptimizedRule to check which dungeons should be generated next given a
list of the dungeons in a chain. DungeonType maps types in packs to ID
numbers and provides a reference to the pack that owns the type.
DungeonPackConfig will carry config information to be passed to the
DungeonPack constructor.
Removed glass from the list of blocks immune to rifts. That was just a
temporary change so that I could check how rifts were destroying blocks
in a controlled manner.
Made it so rifts destroy blocks in layers rather than destroying random
surrounding blocks, even through indestructible blocks. This resolves
issue #24.
Made rifts check block hardness while replacing blocks so that we can
avoid destroying strong or indestructible blocks from other mods.
Updated references throughout the code to use a function in BlockRift
for this purpose.
Added support for rotating the metadata of powered tracks and detector
tracks. Also made a minor change to DungeonSchematic to protect its
internal state.
Changed BlockRotator so that missing stair types are recognized for
applying rotations. The general code for all stairs was there but the
block IDs for wooden and brick stairs weren't recognized. Also removed a
duplicate reference to nether brick stairs.
SenseiKiwi