Made teleporting check whether door is opened and close it again on
teleportation.
Added some more debug logging.
Made the teleportation methods one "string" of boolean methods,
returning false if anything would go amiss.
Implemented 150 ticks waiting time inbetween teleports
finetuned getTeleportTargetLocation method, but it somehow gets reset on
server restart.
Main:
Removed "custom" code for DimDoors' Placement and rewrote it
When right-clicking rifts with any Dimensional Door, the game will try to place the Dimensional Door onto the rift.
Rifts will now enherit their properties from broken DimDoors and Dimdoors will enherit their properties from rifts they are placed over.
Other:
Made the DimDoors logger a bit more powerful.
Made RiftRegistry reset on server-load
Created a setup for the RiftConnectionTool Item.
Layout:
Fixed TileEntityRift.java's indentation
Changed some variable names
Authored by Robijnvogel and squashed by Waterpicker.
-Due to testing, found out that "RiftRegistry.nextRiftID"gets saved and
loaded correctly.
-DimDoors are no longer placeable on leaves or glass (ItemDoorBase.java)
-DimDoors will no longer be placed through left-clicking
(EventHookContainer.java)
-Relocated call to DDTileEntityBase.register() from its constructor to
ItemDoorBase right after the door gets placed. Which means that that
whole constructor and its overrides in other classes are not needed
anymore.
-Added failsafe, so that a DDTileEntityBase that is already registered,
doesn't register again.
Repaired a derp I did in which the Tile Entities did not have a "World"
to get the ID from for the Location to turn into a Location. I needed to
change a lot of constructors to include said "World" as a parameter.
Set up DDTileEntityBase to save after it's paired, registered or
unpaired and actually wrote the readFromNBT and writeToNBT for that.
Merged functionality of "RiftHandler" class into "RiftRegistry" class
Moved the "Location" class
Why the RiftRegistry couples the Rift ID to the Rift **location** and
the PocketRegistry couples the Pocket ID to the actual Pocket
**instance**:
-Each Rift is a Tile-Entity, which means that it has its infromation can
be stored using the Tile-Entitiy's information saving system.
-Each Pocket is barely more than an information storage container, which
depends on having an external information saving system, which the
PocketRegistry provides for it.
If there is a problem reading the blacklist file from disk, previously,
null would be returned from the DDSaveHandler.readBlacklist method. This
would result in a crash later on down the line when we tried to iterate
the blacklist. Now we return an empty array. I'd like to be able to
diagnose the issues causing the blacklist file to be corrupted, but
unfortunately when this issue crops up, people only post the crash :(
If the server disconnected you due to a timeout or whatever, the pocket
manager would appropriately unload all dimension & pocket data, but it
would do so moments before the world unloaded, meaning that entities would
sometimes, on update or as part of their renderer, attempt to access the
dimensional data. This places a new guard condition that attempts to stop
that from crashing the client.
On startup, existing sub-dimensions of personal dimensions were being
given the wrong worldprovider by the launch code. The reason for this is
that subdimensions are not added to the player -> dimension mapping for
personal dimensions, because there is only one canonical "personal"
dimension. The launch code was using presence or absence in the mapping
to determine whether a dimension is personal, rather than the dimension
type. This is now fixed.
Some users were reporting very sporatic crashes in
generateLightBrightnessTable() when the server was starting up. It's
possible that very occasionally, the server will register the pocket
dimension before any pocket dimension data is initialized, forcing the
light brightness table to get generated server side with bad values.
In some cases (such as another mod crashing on startup or something), the
server shutdown even was getting called before anything was actually
initialize. In these cases, some uninitialized objects were having
cleanup methods called on them, when they were null. There are now guard
conditions to prevent the resulting NPE's.
Major change is addition of fractal rift rendering, currently first
pass.
Curves are registered and pregenerated in mod_pocketDim.
Rifts look up these curves, choose one, rotate it, and render it.
The render is a TESR that does stuff. Hard to explain, look at
RenderRift in the code and look at the actual rifts in game to get an
idea of what it does.
I had to add a triangulation library to accomplish this. Will hopefully
do something else that drag around all this.
(I tried(and used comments))
Fixed a crash from manipulating rift data on the client side. I let this
happen because it seemed like TileEntityRift already did that before.
This crash also exposed another issue: that server-side functions are
being used on the client side. I'm not sure how pervasive this is but
some client dimensions are being constructed with the server-side
constructor.
1. Fixed a design flaw in PocketManager. We originally assumed that all
requests to PocketManager.getDimensionData() had to be legitimate
requests for dimensions that existed. That was true in most cases, but
for things like processing user commands, it was dangerously optimistic.
It was possible that a flaw in DD's usage of that function could be
exploited by a player to trick the mod into pre-registering dimension
data for a non-existent dimension. That would declare the dimension as a
root. DD would crash later if Forge ever allocated that ID for a pocket
dimension. The new implementation is almost the same as the old one, but
allows us to differentiate between cases when we can eagerly create
dimension data, and cases in which the absence of a dimension should
cause a crash to alert us of a design flaw.
2. Remove the pocket regeneration code from PocketBuilder. We simply
don't support pocket regeneration and it's unlikely it'll ever be
implemented because it's a difficult issue. Wiping out pockets
completely is easier. We can always recover the code from this commit if
it's needed later.
3. Minor changes: removed some debug prints from PocketManager and
changed some static accesses in PocketBuilder.
Fixed an issue. DD would crash when MC created a completely new world
because onChunkLoad() would be called before onWorldLoad(). That's not
the usual order. PocketManager would be unloaded at that point and would
return a null dimension.
Autocorrected indentation in PocketManager. I'll be working on changing
PocketManager to prevent the risk of creating data for a non-existent
dimension through a bad call to getDimensionData().
Made some improvements to TileEntityRift. The main reason for these
changes was to remove the field nearestRift - we should not hold on to
references to links. Now we simply track the location of the nearest
rift. I also confirmed that closeRift() and updateNearestRift() must be
allowed to run on both the client and the server. If the client doesn't
run those functions, then adjacent rifts don't connect as expected and
the rift removal animation doesn't work.
Removed a pointless check in yCoordHelper and corrected some comments in
RiftRegenerator. It turns out that ChunkProviderServer.chunkExists()
returns whether a chunk is loaded, not whether it has already been
created.
Removed unnecessary code for the Transdimensional Trapdoor. Most of it
was code dedicated to updating TileEntityTransTrapdoor.hasRift. That
flag was never used for anything.
1. Added code so that Transdimensional Trapdoors detect that they have
been broken and schedule rift regeneration at their location. This had
previously been neglected. Trapdoors deserve a little more attention.
2. Tweaked the breakBlock() code for BlockRift and BaseDimDoor so that
rift regeneration is only scheduled if the underlying block was removed.
We don't want that to happen if the only change was for metadata.
1. Removed code from BaseDimDoor that was already implemented almost
identically in BlockDoor. Clarified some uses of setBlock() by changing
them to setBlockToAir() instead.
2. Removed TileEntityDimDoor.invalidate() and moved the regeneration
scheduling code to BaseDimDoor.breakBlock(). I would prefer to move away
from overriding the invalidate() method. This also simplifies the code
since we don't need to perform some of the checks we had in
breakBlock().
1. Made it so that rifts regenerate when rift blocks are replaced by
other blocks.
2. Changed the rift regeneration scheduling functions to streamline
their use in other classes. Common code that was needed to validate
links before calling those functions has been moved into them so that
the checks are always performed internally.