Flipped a Table
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.
This commit is contained in:
SenseiKiwi
235
StevenDimDoors/mod_pocketDim/world/GatewayGenerator.java
Normal file
235
StevenDimDoors/mod_pocketDim/world/GatewayGenerator.java
Normal file
@@ -0,0 +1,235 @@
|
||||
package StevenDimDoors.mod_pocketDim.world;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.chunk.IChunkProvider;
|
||||
import net.minecraftforge.common.DimensionManager;
|
||||
import StevenDimDoors.mod_pocketDim.DDProperties;
|
||||
import StevenDimDoors.mod_pocketDim.mod_pocketDim;
|
||||
import StevenDimDoors.mod_pocketDim.core.IDimLink;
|
||||
import StevenDimDoors.mod_pocketDim.core.NewDimData;
|
||||
import StevenDimDoors.mod_pocketDim.core.PocketManager;
|
||||
import StevenDimDoors.mod_pocketDim.items.itemDimDoor;
|
||||
import cpw.mods.fml.common.IWorldGenerator;
|
||||
|
||||
public class GatewayGenerator implements IWorldGenerator
|
||||
{
|
||||
public static final int MAX_GATEWAY_GENERATION_CHANCE = 10000;
|
||||
public static final int MAX_CLUSTER_GENERATION_CHANCE = 10000;
|
||||
private static final int CLUSTER_GROWTH_CHANCE = 80;
|
||||
private static final int MAX_CLUSTER_GROWTH_CHANCE = 100;
|
||||
private static final int MIN_RIFT_Y = 4;
|
||||
private static final int MAX_RIFT_Y = 250;
|
||||
private static final int CHUNK_LENGTH = 16;
|
||||
private static final int GATEWAY_RADIUS = 4;
|
||||
private static final int MAX_GATEWAY_GENERATION_ATTEMPTS = 10;
|
||||
private static final int NETHER_CHANCE_CORRECTION = 4;
|
||||
private static final int OVERWORLD_DIMENSION_ID = 0;
|
||||
private static final int NETHER_DIMENSION_ID = -1;
|
||||
private static DDProperties properties = null;
|
||||
|
||||
public GatewayGenerator()
|
||||
{
|
||||
if (properties == null)
|
||||
properties = DDProperties.instance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
|
||||
{
|
||||
//Don't generate rifts or gateways if the rift generation flag is disabled,
|
||||
//the current world is a pocket dimension, or the world is remote.
|
||||
if ((!properties.WorldRiftGenerationEnabled && !(world.provider instanceof LimboProvider)) ||
|
||||
world.provider instanceof PocketProvider || world.isRemote)
|
||||
{
|
||||
return;
|
||||
}
|
||||
//This check prevents a crash related to superflat worlds not loading World 0
|
||||
if (DimensionManager.getWorld(OVERWORLD_DIMENSION_ID) == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int x, y, z;
|
||||
int attempts;
|
||||
int correction;
|
||||
boolean valid;
|
||||
IDimLink link;
|
||||
NewDimData dimension;
|
||||
|
||||
//Check if we're generating things in the Nether
|
||||
if (world.provider.dimensionId == NETHER_DIMENSION_ID)
|
||||
{
|
||||
//The terrain in the Nether makes it much harder for our gateway spawning algorithm to find a spot to place a gateway.
|
||||
//Tests show that only about 15% of attempts succeed. Compensate for this by multiplying the chance of generation
|
||||
//by a correction factor.
|
||||
correction = NETHER_CHANCE_CORRECTION;
|
||||
}
|
||||
else
|
||||
{
|
||||
//No correction
|
||||
correction = 1;
|
||||
}
|
||||
|
||||
//Randomly decide whether to place a cluster of rifts here
|
||||
if (random.nextInt(MAX_CLUSTER_GENERATION_CHANCE) < properties.ClusterGenerationChance)
|
||||
{
|
||||
link = null;
|
||||
dimension = null;
|
||||
do
|
||||
{
|
||||
//Pick a random point on the surface of the chunk
|
||||
x = chunkX * CHUNK_LENGTH + random.nextInt(CHUNK_LENGTH);
|
||||
z = chunkZ * CHUNK_LENGTH + random.nextInt(CHUNK_LENGTH);
|
||||
y = world.getHeightValue(x, z);
|
||||
|
||||
//If the point is within the acceptable altitude range, the block above is empty, and we're
|
||||
//not building on bedrock, then generate a rift there
|
||||
if (y >= MIN_RIFT_Y && y <= MAX_RIFT_Y && world.isAirBlock(x, y + 1, z) &&
|
||||
world.getBlockId(x, y, z) != Block.bedrock.blockID && //<-- Stops Nether roof spawning. DO NOT REMOVE!
|
||||
world.getBlockId(x, y - 1, z) != Block.bedrock.blockID &&
|
||||
world.getBlockId(x, y - 2, z) != Block.bedrock.blockID)
|
||||
{
|
||||
//Create a link. If this is not the first time, create a child link and connect it to the first link.
|
||||
if (link == null)
|
||||
{
|
||||
dimension = PocketManager.getDimensionData(world);
|
||||
link = dimension.createLink(x, y + 1, z).setLinkType(IDimLink.TYPE_POCKET);
|
||||
}
|
||||
else
|
||||
{
|
||||
dimension.createChildLink(x, y + 1, z, link);
|
||||
}
|
||||
}
|
||||
}
|
||||
//Randomly decide whether to repeat the process and add another rift to the cluster
|
||||
while (random.nextInt(MAX_CLUSTER_GROWTH_CHANCE) < CLUSTER_GROWTH_CHANCE);
|
||||
}
|
||||
|
||||
//Check if generating structures is enabled and randomly decide whether to place a Rift Gateway here.
|
||||
//This only happens if a rift cluster was NOT generated.
|
||||
else if (random.nextInt(MAX_GATEWAY_GENERATION_CHANCE) < properties.GatewayGenerationChance * correction &&
|
||||
isStructureGenerationAllowed())
|
||||
{
|
||||
valid = false;
|
||||
x = y = z = 0; //Stop the compiler from freaking out
|
||||
|
||||
//Check locations for the gateway until we are satisfied or run out of attempts.
|
||||
for (attempts = 0; attempts < MAX_GATEWAY_GENERATION_ATTEMPTS && !valid; attempts++)
|
||||
{
|
||||
//Pick a random point on the surface of the chunk and check its materials
|
||||
x = chunkX * CHUNK_LENGTH + random.nextInt(CHUNK_LENGTH);
|
||||
z = chunkZ * CHUNK_LENGTH + random.nextInt(CHUNK_LENGTH);
|
||||
y = world.getHeightValue(x, z);
|
||||
valid = checkGatewayLocation(world, x, y, z);
|
||||
}
|
||||
|
||||
//Build the gateway if we found a valid location
|
||||
if (valid)
|
||||
{
|
||||
//Create a partial link to a dungeon.
|
||||
dimension = PocketManager.getDimensionData(world);
|
||||
link = dimension.createLink(x, y + 1, z).setLinkType(IDimLink.TYPE_DUNGEON);
|
||||
|
||||
//If the current dimension isn't Limbo, build a Rift Gateway out of Stone Bricks
|
||||
if (dimension.id() != properties.LimboDimensionID)
|
||||
{
|
||||
createStoneGateway(world, x, y, z, random);
|
||||
}
|
||||
else
|
||||
{
|
||||
createLimboGateway(world, x, y, z);
|
||||
}
|
||||
|
||||
//Place the shiny transient door into a dungeon
|
||||
itemDimDoor.placeDoorBlock(world, x, y + 1, z, 0, mod_pocketDim.transientDoor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void createStoneGateway(World world, int x, int y, int z, Random random)
|
||||
{
|
||||
final int blockID = Block.stoneBrick.blockID;
|
||||
|
||||
//Replace some of the ground around the gateway with bricks
|
||||
for (int xc = -GATEWAY_RADIUS; xc <= GATEWAY_RADIUS; xc++)
|
||||
{
|
||||
for (int zc= -GATEWAY_RADIUS; zc <= GATEWAY_RADIUS; zc++)
|
||||
{
|
||||
//Check that the block is supported by an opaque block.
|
||||
//This prevents us from building over a cliff, on the peak of a mountain,
|
||||
//or the surface of the ocean or a frozen lake.
|
||||
if (world.isBlockOpaqueCube(x + xc, y - 2, z + zc))
|
||||
{
|
||||
//Randomly choose whether to place bricks or not. The math is designed so that the
|
||||
//chances of placing a block decrease as we get farther from the gateway's center.
|
||||
if (Math.abs(xc) + Math.abs(zc) < random.nextInt(2) + 3)
|
||||
{
|
||||
//Place Stone Bricks
|
||||
world.setBlock(x + xc, y - 1, z + zc, blockID, 0, 3);
|
||||
}
|
||||
else if (Math.abs(xc) + Math.abs(zc) < random.nextInt(3) + 3)
|
||||
{
|
||||
//Place Cracked Stone Bricks
|
||||
world.setBlock(x + xc, y - 1, z + zc, blockID, 2, 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Use Chiseled Stone Bricks to top off the pillars around the door
|
||||
world.setBlock(x, y + 2, z + 1, blockID, 3, 3);
|
||||
world.setBlock(x, y + 2, z - 1, blockID, 3, 3);
|
||||
//Build the columns around the door
|
||||
world.setBlock(x, y + 1, z - 1, blockID, 0, 3);
|
||||
world.setBlock(x, y + 1, z + 1, blockID, 0, 3);
|
||||
world.setBlock(x, y, z - 1, blockID, 0, 3);
|
||||
world.setBlock(x, y, z + 1, blockID, 0, 3);
|
||||
}
|
||||
|
||||
private static void createLimboGateway(World world, int x, int y, int z)
|
||||
{
|
||||
//Build the gateway out of Unraveled Fabric. Since nearly all the blocks in Limbo are of
|
||||
//that type, there is no point replacing the ground.
|
||||
final int blockID = properties.LimboBlockID;
|
||||
world.setBlock(x, y + 2, z + 1, blockID, 0, 3);
|
||||
world.setBlock(x, y + 2, z - 1, blockID, 0, 3);
|
||||
|
||||
//Build the columns around the door
|
||||
world.setBlock(x, y + 1, z - 1, blockID, 0, 3);
|
||||
world.setBlock(x, y + 1, z + 1, blockID, 0, 3);
|
||||
world.setBlock(x, y, z - 1, blockID, 0, 3);
|
||||
world.setBlock(x, y, z + 1, blockID, 0, 3);
|
||||
}
|
||||
|
||||
private static boolean checkGatewayLocation(World world, int x, int y, int z)
|
||||
{
|
||||
//Check if the point is within the acceptable altitude range, the block above that point is empty,
|
||||
//and the block two levels down is opaque and has a reasonable material. Plus that we're not building
|
||||
//on top of bedrock.
|
||||
return (y >= MIN_RIFT_Y &&
|
||||
y <= MAX_RIFT_Y &&
|
||||
world.isAirBlock(x, y + 1, z) &&
|
||||
world.getBlockId(x, y, z) != Block.bedrock.blockID && //<-- Stops Nether roof spawning. DO NOT REMOVE!
|
||||
world.getBlockId(x, y - 1, z) != Block.bedrock.blockID &&
|
||||
checkFoundationMaterial(world, x, y - 2, z));
|
||||
}
|
||||
|
||||
private static boolean checkFoundationMaterial(World world, int x, int y, int z)
|
||||
{
|
||||
//We check the material and opacity to prevent generating gateways on top of trees or houses,
|
||||
//or on top of strange things like tall grass, water, slabs, or torches.
|
||||
//We also want to avoid generating things on top of the Nether's bedrock!
|
||||
Material material = world.getBlockMaterial(x, y, z);
|
||||
return (material != Material.leaves && material != Material.wood && material != Material.pumpkin
|
||||
&& world.isBlockOpaqueCube(x, y, z) && world.getBlockId(x, y, z) != Block.bedrock.blockID);
|
||||
}
|
||||
|
||||
private static boolean isStructureGenerationAllowed()
|
||||
{
|
||||
return DimensionManager.getWorld(OVERWORLD_DIMENSION_ID).getWorldInfo().isMapFeaturesEnabled();
|
||||
}
|
||||
}
|
||||
422
StevenDimDoors/mod_pocketDim/world/PocketBuilder.java
Normal file
422
StevenDimDoors/mod_pocketDim/world/PocketBuilder.java
Normal file
@@ -0,0 +1,422 @@
|
||||
package StevenDimDoors.mod_pocketDim.world;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Random;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
|
||||
import net.minecraftforge.common.DimensionManager;
|
||||
import StevenDimDoors.mod_pocketDim.DDProperties;
|
||||
import StevenDimDoors.mod_pocketDim.Point3D;
|
||||
import StevenDimDoors.mod_pocketDim.core.IDimLink;
|
||||
import StevenDimDoors.mod_pocketDim.core.NewDimData;
|
||||
import StevenDimDoors.mod_pocketDim.core.PocketManager;
|
||||
import StevenDimDoors.mod_pocketDim.dungeon.DungeonData;
|
||||
import StevenDimDoors.mod_pocketDim.dungeon.DungeonSchematic;
|
||||
import StevenDimDoors.mod_pocketDim.dungeon.pack.DungeonPackConfig;
|
||||
import StevenDimDoors.mod_pocketDim.helpers.DungeonHelper;
|
||||
import StevenDimDoors.mod_pocketDim.helpers.yCoordHelper;
|
||||
import StevenDimDoors.mod_pocketDim.schematic.BlockRotator;
|
||||
import StevenDimDoors.mod_pocketDim.util.Point4D;
|
||||
|
||||
public class PocketBuilder
|
||||
{
|
||||
public static final int MIN_POCKET_SIZE = 5;
|
||||
public static final int MAX_POCKET_SIZE = 51;
|
||||
public static final int DEFAULT_POCKET_SIZE = 39;
|
||||
|
||||
public static final int MIN_POCKET_WALL_THICKNESS = 1;
|
||||
public static final int MAX_POCKET_WALL_THICKNESS = 10;
|
||||
public static final int DEFAULT_POCKET_WALL_THICKNESS = 5;
|
||||
|
||||
private static final Random random = new Random();
|
||||
|
||||
private PocketBuilder() { }
|
||||
|
||||
public static boolean initializeDestination(IDimLink link, DDProperties properties)
|
||||
{
|
||||
if (link.hasDestination())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
//Check the destination type and respond accordingly
|
||||
switch (link.linkType())
|
||||
{
|
||||
case IDimLink.TYPE_DUNGEON:
|
||||
return generateNewDungeonPocket(link, properties);
|
||||
case IDimLink.TYPE_POCKET:
|
||||
return generateNewPocket(link, properties);
|
||||
default:
|
||||
throw new IllegalArgumentException("link has an unrecognized link type.");
|
||||
}
|
||||
}
|
||||
|
||||
public static boolean generateNewDungeonPocket(IDimLink link, DDProperties properties)
|
||||
{
|
||||
if (link == null)
|
||||
{
|
||||
throw new IllegalArgumentException("link cannot be null.");
|
||||
}
|
||||
if (properties == null)
|
||||
{
|
||||
throw new IllegalArgumentException("properties cannot be null.");
|
||||
}
|
||||
if (link.hasDestination())
|
||||
{
|
||||
throw new IllegalArgumentException("link cannot have a destination assigned already.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
//Register a new dimension
|
||||
NewDimData parent = PocketManager.getDimensionData(link.source().getDimension());
|
||||
NewDimData dimension = PocketManager.registerPocket(parent, false);
|
||||
|
||||
//Load a world
|
||||
World world = DimensionManager.getWorld(dimension.id());
|
||||
|
||||
if (world == null)
|
||||
{
|
||||
DimensionManager.initDimension(dimension.id());
|
||||
world = DimensionManager.getWorld(dimension.id());
|
||||
}
|
||||
if (world != null && world.provider == null)
|
||||
{
|
||||
DimensionManager.initDimension(dimension.id());
|
||||
}
|
||||
if (world == null || world.provider == null)
|
||||
{
|
||||
System.err.println("Could not initialize dimension for a dungeon!");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* This code is currently wrong. It's missing the following things:
|
||||
* 1. Calculate the destination point for real. That includes adding door noise if needed.
|
||||
* 2. Receive the DungeonData from selectDungeon()
|
||||
* 3. The function signature for DungeonSchematic.copyToWorld() has to be rewritten.
|
||||
*/
|
||||
|
||||
//Choose a dungeon to generate
|
||||
DungeonSchematic schematic = selectDungeon(dimension, random, properties);
|
||||
|
||||
if (schematic == null)
|
||||
{
|
||||
System.err.println("Could not select a dungeon for generation!");
|
||||
return false;
|
||||
}
|
||||
|
||||
//Calculate the destination point
|
||||
Point4D source = link.source();
|
||||
int destinationY = yCoordHelper.adjustDestinationY(destination, world.getHeight(), schematic.getEntranceDoorLocation().getY(), schematic.getHeight());
|
||||
int orientation = getDestinationOrientation(source);
|
||||
destination.setY(destinationY);
|
||||
|
||||
//Generate the dungeon
|
||||
DungeonPackConfig packConfig = dungeon.dungeonType().Owner != null ? dungeon.dungeonType().Owner.getConfig() : null;
|
||||
|
||||
schematic.copyToWorld(world, link, packConfig.doDistortDoorCoordinates());
|
||||
|
||||
//Finish up destination initialization
|
||||
dimension.initializePocket(destination.getX(), destination.getY(), destination.getZ(), orientation, link);
|
||||
dimension.setFilled(true);
|
||||
return true;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static DungeonSchematic selectDungeon(NewDimData dimension, Random random, DDProperties properties)
|
||||
{
|
||||
//We assume the dimension doesn't have a dungeon assigned
|
||||
if (dimension.dungeon() != null)
|
||||
{
|
||||
throw new IllegalArgumentException("dimension cannot have a dungeon assigned already.");
|
||||
}
|
||||
|
||||
DungeonData dungeon = null;
|
||||
DungeonSchematic schematic = null;
|
||||
|
||||
dungeon = DungeonHelper.instance().selectDungeon(dimension, random);
|
||||
|
||||
if (dungeon != null)
|
||||
{
|
||||
schematic = loadAndValidateDungeon(dungeon, properties);
|
||||
}
|
||||
else
|
||||
{
|
||||
System.err.println("Could not select a dungeon at all!");
|
||||
}
|
||||
|
||||
if (schematic == null)
|
||||
{
|
||||
//TODO: In the future, remove this dungeon from the generation lists altogether.
|
||||
//That will have to wait until our code is updated to support that more easily.
|
||||
|
||||
try
|
||||
{
|
||||
System.err.println("Loading the default error dungeon instead...");
|
||||
dungeon = DungeonHelper.instance().getDefaultErrorDungeon();
|
||||
schematic = loadAndValidateDungeon(dungeon, properties);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return schematic;
|
||||
}
|
||||
|
||||
private static DungeonSchematic loadAndValidateDungeon(DungeonData dungeon, DDProperties properties)
|
||||
{
|
||||
try
|
||||
{
|
||||
DungeonSchematic schematic = dungeon.loadSchematic();
|
||||
|
||||
//Validate the dungeon's dimensions
|
||||
if (hasValidDimensions(schematic))
|
||||
{
|
||||
schematic.applyImportFilters(properties);
|
||||
|
||||
//Check that the dungeon has an entrance or we'll have a crash
|
||||
if (schematic.getEntranceDoorLocation() == null)
|
||||
{
|
||||
System.err.println("The following schematic file does not have an entrance: " + dungeon.schematicPath());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
System.err.println("The following schematic file has dimensions that exceed the maximum permitted dimensions for dungeons: " + dungeon.schematicPath());
|
||||
return null;
|
||||
}
|
||||
return schematic;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
System.err.println("An error occurred while loading the following schematic: " + dungeon.schematicPath());
|
||||
System.err.println(e.getMessage());
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean hasValidDimensions(DungeonSchematic schematic)
|
||||
{
|
||||
return (schematic.getWidth() <= DungeonHelper.MAX_DUNGEON_WIDTH &&
|
||||
schematic.getHeight() <= DungeonHelper.MAX_DUNGEON_HEIGHT &&
|
||||
schematic.getLength() <= DungeonHelper.MAX_DUNGEON_LENGTH);
|
||||
}
|
||||
|
||||
public static boolean generateNewPocket(IDimLink link, DDProperties properties)
|
||||
{
|
||||
return generateNewPocket(link, DEFAULT_POCKET_SIZE, DEFAULT_POCKET_WALL_THICKNESS, properties);
|
||||
}
|
||||
|
||||
private static int getDestinationOrientation(Point4D source)
|
||||
{
|
||||
// TODO Auto-generated method stub
|
||||
return 0;
|
||||
}
|
||||
|
||||
public static boolean generateNewPocket(IDimLink link, int size, int wallThickness, DDProperties properties)
|
||||
{
|
||||
if (link == null)
|
||||
{
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
if (properties == null)
|
||||
{
|
||||
throw new IllegalArgumentException("properties cannot be null.");
|
||||
}
|
||||
if (link.hasDestination())
|
||||
{
|
||||
throw new IllegalArgumentException("link cannot have a destination assigned already.");
|
||||
}
|
||||
|
||||
if (size < MIN_POCKET_SIZE || size > MAX_POCKET_SIZE)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be between " + MIN_POCKET_SIZE + " and " + MAX_POCKET_SIZE + ", inclusive.");
|
||||
}
|
||||
if (wallThickness < MIN_POCKET_WALL_THICKNESS || wallThickness > MAX_POCKET_WALL_THICKNESS)
|
||||
{
|
||||
throw new IllegalArgumentException("wallThickness must be between " + MIN_POCKET_WALL_THICKNESS + " and " + MAX_POCKET_WALL_THICKNESS + ", inclusive.");
|
||||
}
|
||||
if (size % 2 == 0)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be an odd number.");
|
||||
}
|
||||
if (size < 2 * wallThickness + 3)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be large enough to fit the specified wall thickness and some air space.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
//Register a new dimension
|
||||
NewDimData parent = PocketManager.getDimensionData(link.source().getDimension());
|
||||
NewDimData dimension = PocketManager.registerPocket(parent, false);
|
||||
|
||||
//Load a world
|
||||
World world = DimensionManager.getWorld(dimension.id());
|
||||
|
||||
if (world == null)
|
||||
{
|
||||
DimensionManager.initDimension(dimension.id());
|
||||
world = DimensionManager.getWorld(dimension.id());
|
||||
}
|
||||
if (world != null && world.provider == null)
|
||||
{
|
||||
DimensionManager.initDimension(dimension.id());
|
||||
}
|
||||
if (world == null || world.provider == null)
|
||||
{
|
||||
System.err.println("Could not initialize dimension for a pocket!");
|
||||
return false;
|
||||
}
|
||||
|
||||
//Calculate the destination point
|
||||
Point4D source = link.source();
|
||||
int destinationY = yCoordHelper.adjustDestinationY(source.getY(), world.getHeight(), wallThickness + 1, size);
|
||||
int orientation = getDestinationOrientation(source);
|
||||
|
||||
//Build the actual pocket area
|
||||
buildPocket(world, source.getX(), destinationY, source.getZ(), orientation, size, wallThickness, properties);
|
||||
|
||||
//Finish up destination initialization
|
||||
dimension.initializePocket(source.getX(), destinationY, source.getZ(), orientation, link);
|
||||
dimension.setFilled(true);
|
||||
return true;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static void buildPocket(World world, int x, int y, int z, int orientation, int size, int wallThickness, DDProperties properties)
|
||||
{
|
||||
if (properties == null)
|
||||
{
|
||||
throw new IllegalArgumentException("properties cannot be null.");
|
||||
}
|
||||
if (size < MIN_POCKET_SIZE || size > MAX_POCKET_SIZE)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be between " + MIN_POCKET_SIZE + " and " + MAX_POCKET_SIZE + ", inclusive.");
|
||||
}
|
||||
if (wallThickness < MIN_POCKET_WALL_THICKNESS || wallThickness > MAX_POCKET_WALL_THICKNESS)
|
||||
{
|
||||
throw new IllegalArgumentException("wallThickness must be between " + MIN_POCKET_WALL_THICKNESS + " and " + MAX_POCKET_WALL_THICKNESS + ", inclusive.");
|
||||
}
|
||||
if (size % 2 == 0)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be an odd number.");
|
||||
}
|
||||
if (size < 2 * wallThickness + 3)
|
||||
{
|
||||
throw new IllegalArgumentException("size must be large enough to fit the specified wall thickness and some air space.");
|
||||
}
|
||||
|
||||
Point3D center = new Point3D(x - wallThickness + 1 + (size / 2), y - wallThickness - 1 + (size / 2), z);
|
||||
Point3D door = new Point3D(x, y, z);
|
||||
BlockRotator.transformPoint(center, door, orientation - BlockRotator.EAST_DOOR_METADATA, door);
|
||||
|
||||
//Build the outer layer of Eternal Fabric
|
||||
buildBox(world, center.getX(), center.getY(), center.getZ(), (size / 2), properties.PermaFabricBlockID, false, 0);
|
||||
|
||||
//Build the (wallThickness - 1) layers of Fabric of Reality
|
||||
for (int layer = 1; layer < wallThickness; layer++)
|
||||
{
|
||||
buildBox(world, center.getX(), center.getY(), center.getZ(), (size / 2) - layer, properties.FabricBlockID,
|
||||
layer < (wallThickness - 1) && properties.TNFREAKINGT_Enabled, properties.NonTntWeight);
|
||||
}
|
||||
|
||||
//Build the door
|
||||
int metadata = BlockRotator.transformMetadata(BlockRotator.EAST_DOOR_METADATA, orientation - BlockRotator.EAST_DOOR_METADATA, properties.DimensionalDoorID);
|
||||
setBlockDirectly(world, x, y, z, properties.DimensionalDoorID, metadata);
|
||||
setBlockDirectly(world, x, y - 1, z, properties.DimensionalDoorID, metadata);
|
||||
}
|
||||
|
||||
private static void buildBox(World world, int centerX, int centerY, int centerZ, int radius, int blockID, boolean placeTnt, int nonTntWeight)
|
||||
{
|
||||
int x, y, z;
|
||||
|
||||
final int startX = centerX - radius;
|
||||
final int startY = centerY - radius;
|
||||
final int startZ = centerZ - radius;
|
||||
|
||||
final int endX = centerX + radius;
|
||||
final int endY = centerY + radius;
|
||||
final int endZ = centerZ + radius;
|
||||
|
||||
//Build faces of the box
|
||||
for (x = startX; x <= endX; x++)
|
||||
{
|
||||
for (z = startZ; z <= endZ; z++)
|
||||
{
|
||||
setBlockDirectlySpecial(world, x, startY, z, blockID, 0, placeTnt, nonTntWeight);
|
||||
setBlockDirectlySpecial(world, x, endY, z, blockID, 0, placeTnt, nonTntWeight);
|
||||
}
|
||||
|
||||
for (y = startY; y <= endY; y++)
|
||||
{
|
||||
setBlockDirectlySpecial(world, x, y, startZ, blockID, 0, placeTnt, nonTntWeight);
|
||||
setBlockDirectlySpecial(world, x, y, endZ, blockID, 0, placeTnt, nonTntWeight);
|
||||
}
|
||||
}
|
||||
|
||||
for (y = startY; y <= endY; y++)
|
||||
{
|
||||
for (z = startZ; z <= endZ; z++)
|
||||
{
|
||||
setBlockDirectlySpecial(world, startX, y, z, blockID, 0, placeTnt, nonTntWeight);
|
||||
setBlockDirectlySpecial(world, endX, y, z, blockID, 0, placeTnt, nonTntWeight);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void setBlockDirectlySpecial(World world, int x, int y, int z, int blockID, int metadata, boolean placeTnt, int nonTntWeight)
|
||||
{
|
||||
if (placeTnt && random.nextInt(nonTntWeight + 1) == 0)
|
||||
{
|
||||
setBlockDirectly(world, x, y, z, Block.tnt.blockID, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
setBlockDirectly(world, x, y, z, blockID, metadata);
|
||||
}
|
||||
}
|
||||
|
||||
private static void setBlockDirectly(World world, int x, int y, int z, int blockID, int metadata)
|
||||
{
|
||||
if (blockID != 0 && Block.blocksList[blockID] == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
int cX = x >> 4;
|
||||
int cZ = z >> 4;
|
||||
int cY = y >> 4;
|
||||
Chunk chunk;
|
||||
|
||||
int localX = (x % 16) < 0 ? (x % 16) + 16 : (x % 16);
|
||||
int localZ = (z % 16) < 0 ? (z % 16) + 16 : (z % 16);
|
||||
ExtendedBlockStorage extBlockStorage;
|
||||
|
||||
chunk = world.getChunkFromChunkCoords(cX, cZ);
|
||||
extBlockStorage = chunk.getBlockStorageArray()[cY];
|
||||
if (extBlockStorage == null)
|
||||
{
|
||||
extBlockStorage = new ExtendedBlockStorage(cY << 4, !world.provider.hasNoSky);
|
||||
chunk.getBlockStorageArray()[cY] = extBlockStorage;
|
||||
}
|
||||
extBlockStorage.setExtBlockID(localX, y & 15, localZ, blockID);
|
||||
extBlockStorage.setExtBlockMetadata(localX, y & 15, localZ, metadata);
|
||||
}
|
||||
}
|
||||
@@ -8,8 +8,8 @@ import net.minecraft.world.World;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
import net.minecraft.world.chunk.IChunkProvider;
|
||||
import net.minecraft.world.gen.ChunkProviderGenerate;
|
||||
import StevenDimDoors.mod_pocketDim.DimData;
|
||||
import StevenDimDoors.mod_pocketDim.helpers.dimHelper;
|
||||
import StevenDimDoors.mod_pocketDim.core.NewDimData;
|
||||
import StevenDimDoors.mod_pocketDim.core.PocketManager;
|
||||
import StevenDimDoors.mod_pocketDim.ticking.MonolithSpawner;
|
||||
|
||||
public class PocketGenerator extends ChunkProviderGenerate implements IChunkProvider
|
||||
@@ -69,16 +69,10 @@ public class PocketGenerator extends ChunkProviderGenerate implements IChunkProv
|
||||
@Override
|
||||
public List getPossibleCreatures(EnumCreatureType var1, int var2, int var3, int var4)
|
||||
{
|
||||
DimData data = dimHelper.instance.getDimData(this.worldObj.provider.dimensionId);
|
||||
if (data != null)
|
||||
NewDimData dimension = PocketManager.getDimensionData(this.worldObj);
|
||||
if (dimension != null && dimension.dungeon() != null && !dimension.dungeon().isOpen())
|
||||
{
|
||||
if (data.dungeonGenerator != null)
|
||||
{
|
||||
if (data.isDimRandomRift && data.isPocket && !data.dungeonGenerator.isOpen)
|
||||
{
|
||||
return this.worldObj.getBiomeGenForCoords(var2, var3).getSpawnableList(var1);
|
||||
}
|
||||
}
|
||||
return this.worldObj.getBiomeGenForCoords(var2, var3).getSpawnableList(var1);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -6,10 +6,11 @@ import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.WorldProvider;
|
||||
import net.minecraft.world.biome.WorldChunkManagerHell;
|
||||
import net.minecraft.world.chunk.IChunkProvider;
|
||||
import net.minecraftforge.common.DimensionManager;
|
||||
import StevenDimDoors.mod_pocketDim.CloudRenderBlank;
|
||||
import StevenDimDoors.mod_pocketDim.DDProperties;
|
||||
import StevenDimDoors.mod_pocketDim.mod_pocketDim;
|
||||
import StevenDimDoors.mod_pocketDim.helpers.dimHelper;
|
||||
import StevenDimDoors.mod_pocketDim.core.PocketManager;
|
||||
import StevenDimDoors.mod_pocketDim.ticking.MonolithSpawner;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
@@ -113,12 +114,12 @@ public class PocketProvider extends WorldProvider
|
||||
}
|
||||
else
|
||||
{
|
||||
respawnDim = dimHelper.instance.getDimData(this.dimensionId).exitDimLink.destDimID;
|
||||
respawnDim = PocketManager.getDimensionData(this.dimensionId).root().id();
|
||||
}
|
||||
|
||||
if (dimHelper.getWorld(respawnDim) == null)
|
||||
if (DimensionManager.getWorld(respawnDim) == null)
|
||||
{
|
||||
dimHelper.initDimension(respawnDim);
|
||||
DimensionManager.initDimension(respawnDim);
|
||||
}
|
||||
return respawnDim;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user