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.
1. Implemented scheduled rift regeneration in RiftRegenerator. The
previous randomized selection algorithm has been removed completely. All
regeneration is scheduled now. We perform numerous checks to make sure
that regenerating a rift is safe.
2. Removed FastRiftRegenerator as RiftRegenerator performs roughly the
same task but with more flexibility. Updated TileEntityDimDoor to use
RiftRegenerator instead for creating rifts when doors are broken.
3. Modified EventHookContainer to receive the chunk loaded event. We
iterate over the list of links in a loaded chunk and schedule them for
regeneration.
4. Reorganized the code in BlockRift. Divided the list of immune blocks
into two lists - one for DD blocks and one for regular MC blocks.
RiftRegenerator has to be able to distinguish between the two types.
5. Factored out some duplicate code from ItemRiftSignature and
ItemStabilizedRiftSignature. Most of the block immunity checks were used
to check if it would be safe to spawn a rift when using one of those
items. BlockRift.tryPlacingRift() covers all that logic in a single
function and makes the item code a little simpler.
Minor changes to DimLink to simplify DimLink.getDestinationOrientation()
and to clarify the output of DimLink.toString() when no destination is
available.
Rewrote the NewDimData.deleteLink() version that would accept x, y, and
z as parameters. There was some redundant code for getting the
parameters from a Point4D instance just to create another one to find
the target link. Now we pass the source point in directly.
Made some minor changes to NewDimData. Fixed some comments for the rift
search functions that incorrectly indicated the search would not detect
rifts adjacent to the center of the search range. That behavior changed
some time ago. Also added an unused field called "chunkMapping" for
associating chunks with lists of links. It'll be used for implementing
queuing of rift regeneration when chunks load.
1. Reorganized our code to initialize tick receivers each time the
server starts rather than once when the mod is initialized. This is
needed because reusing a single instance of each class across different
single-player sessions could cause scheduled events for one world to
leak into another world. This approach ensures that we discard all
pending events.
2. Separated the implementation of Limbo decay from a tick receiver that
periodically triggers fast decay. All of the decay code has been kept in
LimboDecay, while the ticking is handled by LimboDecayScheduler. This
change separates some functionality that should be independent, but
also, it's needed so that BlockLimbo can have access to LimboDecay's
methods without holding on to a tick receiver instance.
3. Minor change: renamed ChunkLoaderHelper.loadChunkForcedWorlds() to
loadForcedChunkWorlds().
1. Renamed CommonTickHandler to ServerTickHandler. Given that it only
handles server ticks, this seems like a reasonable name. Also changed
its profiler label to the new name.
2. Deleted ClientTickHandler and removed any references to it in
mod_pocketDim. It was never used for anything.
Made various changes to clarify code in DDTeleporter. For instance, we
had a whole switch block that was used to give the same outcome on every
case except the default. I rewrote the code there to remove the block.
Also changed DDTeleporter.checkDestination() since it was redoing the
destination orientation checks unnecessarily, changing the entity's yaw
when it shouldn't have side effects, and some other little things.
1. Changed build.gradle so that it edits the version numbers in
mod_pocketDim.java and mcmod.info.
2. Changed mod_pocketDim to use a placeholder for its version number and
fixed an annotation that was wrong. It would cause our mod_pocketDim
instance to not initialize properly. I removed what seemed to be
workarounds that were hiding the problem.
3. Fixed space in TileEntityDimDoor.invalidate() and corrected a
non-static access to a static field in mod_pocketDim.
4. Changed mcmod.info so that it users placeholders for the mod version
and MC version values.
We previously returned the Vanilla counterparts to our doors as the
items to be used by the pick block button - used in Creative mode for
replicating nearby blocks. This was incorrect because we would want to
return the actual door item needed to place the particular door in
question.
More importantly, this might solve our issues with WAILA reporting the
wrong information when players look at our doors. I read the code for
the most recent version of WAILA and it uses various functions to choose
how to identify a block. The result of Block.idPicked() is probably used
as the main source for the identities of our blocks.
Fixed the way in which we handle redirecting links to blacklisted
dimensions. The previous method always converted links into safe exits.
This lead to strange situations that could be seen as bugs. For
instance, using a dungeon entrance in a root dimension would generate an
exit door and a supporting platform directly above the entrance door.
That also meant that any visited dungeons would be unusable if they were
reset.
We now do different things depending on the location of the link and its
type. If the link is a dungeon link, then its destination is reset to
allow a new dungeon to form. For other link types, if the link is in a
pocket dimension, then it becomes a safe exit link, because it could be
the only way out. If it's in a root dimension, then there are no
reasonable destinations, so the teleport request is cancelled.
Made some minor changes to DDTeleporter to get rid of a few warnings.
Also tweaked and commented DDTeleporter.initializeDestination(). There
were inappropriate references to a link's internal variables instead of
using its getters and there was a subtle link overwrite for blacklist
destinations. Without comments, it would probably be unclear that
overwriting that link is safe. This changes are in preparation for
fixing issues with blacklisted destination redirection.
Rewrote CommandTeleportPlayer for the same reason as usual. There were a
few bugs before, such as that lookups for players were limited to within
the world from which the command sender was using the command. Players
in other dimensions could not be teleported. The command would also
place people in the ground because it did not adjust its coordinates for
the way that DDTeleporter interprets them - as the location of the top
block of a door and the player's head.
I removed CommandDeleteAllLinks because of the significant risk that it
would harm a server. It's possible that someone could run this by
accident instead of CommandDeleteRifts. It takes the same arguments or
even no arguments and it would immediately wipe all links in a
dimension. We can restore it later if it's really needed.
Added a minor check to PocketManager.loadDimension() so that an attempt
to load an unregistered dimension won't be passed on to Forge where it
would cause an exception - which is then caught by Forge before it can
cause problems. This isn't strictly necessary, but it's a nice
consideration.
Increased the maximum Monolith aggro level and the cap range values by a
factor of 1.25. The max aggro increase is to slow down how long it takes
Monoliths to max out because they're just a little too fast right now.
The cap adjustments will preserve the range of texture states they can
have while idling.
1. Rewrote CommandResetDungeons to improve clarity and remove bugs. This
version of the command preserves valid links. Those were previously
removed, which would break some dungeons unnecessarily.
2. Fixed NewDimData.setParentToRoot(). The function did not account for
the possibility that the target's parent might still exist and would
need to be updated, leading to conflicting data. It also did not reset
pack depth. We now correctly update a dimension and all its descendants.
