1ac934b5e4
Added code to SchematicLoader so that we can import tile entities. Empty chests and dispensers will still be filled as before.
768 lines
No EOL
28 KiB
Java
768 lines
No EOL
28 KiB
Java
package StevenDimDoors.mod_pocketDim.helpers;
|
|
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Random;
|
|
import java.util.regex.Pattern;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.nbt.CompressedStreamTools;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.WeightedRandom;
|
|
import net.minecraft.world.World;
|
|
import StevenDimDoors.mod_pocketDim.DDProperties;
|
|
import StevenDimDoors.mod_pocketDim.DimData;
|
|
import StevenDimDoors.mod_pocketDim.DungeonGenerator;
|
|
import StevenDimDoors.mod_pocketDim.LinkData;
|
|
import StevenDimDoors.mod_pocketDim.mod_pocketDim;
|
|
import StevenDimDoors.mod_pocketDim.items.itemDimDoor;
|
|
import StevenDimDoors.mod_pocketDim.util.WeightedContainer;
|
|
|
|
public class DungeonHelper
|
|
{
|
|
private static DungeonHelper instance = null;
|
|
private static DDProperties properties = null;
|
|
public static final Pattern SchematicNamePattern = Pattern.compile("[A-Za-z0-9_\\-]+");
|
|
public static final Pattern DungeonNamePattern = Pattern.compile("[A-Za-z0-9\\-]+");
|
|
|
|
public static final String SCHEMATIC_FILE_EXTENSION = ".schematic";
|
|
private static final int DEFAULT_DUNGEON_WEIGHT = 100;
|
|
public static final int MAX_DUNGEON_WEIGHT = 10000; //Used to prevent overflows and math breaking down
|
|
private static final int MAX_EXPORT_RADIUS = 50;
|
|
|
|
public static final int FABRIC_OF_REALITY_EXPORT_ID = 1973;
|
|
public static final int PERMAFABRIC_EXPORT_ID = 220;
|
|
|
|
private static final String HUB_DUNGEON_TYPE = "Hub";
|
|
private static final String TRAP_DUNGEON_TYPE = "Trap";
|
|
private static final String SIMPLE_HALL_DUNGEON_TYPE = "SimpleHall";
|
|
private static final String COMPLEX_HALL_DUNGEON_TYPE = "ComplexHall";
|
|
private static final String EXIT_DUNGEON_TYPE = "Exit";
|
|
private static final String DEAD_END_DUNGEON_TYPE = "DeadEnd";
|
|
private static final String MAZE_DUNGEON_TYPE = "Maze";
|
|
|
|
//The list of dungeon types will be kept as an array for now. If we allow new
|
|
//dungeon types in the future, then this can be changed to an ArrayList.
|
|
private static final String[] DUNGEON_TYPES = new String[] {
|
|
HUB_DUNGEON_TYPE,
|
|
TRAP_DUNGEON_TYPE,
|
|
SIMPLE_HALL_DUNGEON_TYPE,
|
|
COMPLEX_HALL_DUNGEON_TYPE,
|
|
EXIT_DUNGEON_TYPE,
|
|
DEAD_END_DUNGEON_TYPE,
|
|
MAZE_DUNGEON_TYPE
|
|
};
|
|
|
|
private Random rand = new Random();
|
|
|
|
private HashMap<Integer, LinkData> customDungeonStatus = new HashMap<Integer, LinkData>();
|
|
|
|
public ArrayList<DungeonGenerator> customDungeons = new ArrayList<DungeonGenerator>();
|
|
public ArrayList<DungeonGenerator> registeredDungeons = new ArrayList<DungeonGenerator>();
|
|
|
|
private ArrayList<DungeonGenerator> simpleHalls = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> complexHalls = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> deadEnds = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> hubs = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> mazes = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> pistonTraps = new ArrayList<DungeonGenerator>();
|
|
private ArrayList<DungeonGenerator> exits = new ArrayList<DungeonGenerator>();
|
|
|
|
public ArrayList<Integer> metadataFlipList = new ArrayList<Integer>();
|
|
public ArrayList<Integer> metadataNextList = new ArrayList<Integer>();
|
|
public DungeonGenerator defaultBreak = new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/somethingBroke.schematic", true);
|
|
public DungeonGenerator defaultUp = new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleStairsUp.schematic", true);
|
|
|
|
private HashSet<String> dungeonTypeChecker;
|
|
private HashMap<String, ArrayList<DungeonGenerator>> dungeonTypeMapping;
|
|
|
|
private DungeonHelper()
|
|
{
|
|
//Load the dungeon type checker with the list of all types in lowercase.
|
|
//Capitalization matters for matching in a hash set.
|
|
dungeonTypeChecker = new HashSet<String>();
|
|
for (String dungeonType : DUNGEON_TYPES)
|
|
{
|
|
dungeonTypeChecker.add(dungeonType.toLowerCase());
|
|
}
|
|
|
|
//Add all the basic dungeon types to dungeonTypeMapping
|
|
//Dungeon type names must be passed in lowercase to make matching easier.
|
|
dungeonTypeMapping = new HashMap<String, ArrayList<DungeonGenerator>>();
|
|
dungeonTypeMapping.put(SIMPLE_HALL_DUNGEON_TYPE.toLowerCase(), simpleHalls);
|
|
dungeonTypeMapping.put(COMPLEX_HALL_DUNGEON_TYPE.toLowerCase(), complexHalls);
|
|
dungeonTypeMapping.put(HUB_DUNGEON_TYPE.toLowerCase(), hubs);
|
|
dungeonTypeMapping.put(EXIT_DUNGEON_TYPE.toLowerCase(), exits);
|
|
dungeonTypeMapping.put(DEAD_END_DUNGEON_TYPE.toLowerCase(), deadEnds);
|
|
dungeonTypeMapping.put(MAZE_DUNGEON_TYPE.toLowerCase(), mazes);
|
|
dungeonTypeMapping.put(TRAP_DUNGEON_TYPE.toLowerCase(), pistonTraps);
|
|
|
|
//Load our reference to the DDProperties singleton
|
|
if (properties == null)
|
|
properties = DDProperties.instance();
|
|
|
|
registerCustomDungeons();
|
|
}
|
|
|
|
private void registerCustomDungeons()
|
|
{
|
|
File file = new File(properties.CustomSchematicDirectory);
|
|
if (file.exists() || file.mkdir())
|
|
{
|
|
copyfile.copyFile("/mods/DimDoors/text/How_to_add_dungeons.txt", file.getAbsolutePath() + "/How_to_add_dungeons.txt");
|
|
}
|
|
registerFlipBlocks();
|
|
importCustomDungeons(properties.CustomSchematicDirectory);
|
|
registerBaseDungeons();
|
|
}
|
|
|
|
public static DungeonHelper initialize()
|
|
{
|
|
if (instance == null)
|
|
{
|
|
instance = new DungeonHelper();
|
|
}
|
|
else
|
|
{
|
|
throw new IllegalStateException("Cannot initialize DungeonHelper twice");
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
|
|
public static DungeonHelper instance()
|
|
{
|
|
if (instance == null)
|
|
{
|
|
//This is to prevent some frustrating bugs that could arise when classes
|
|
//are loaded in the wrong order. Trust me, I had to squash a few...
|
|
throw new IllegalStateException("Instance of DungeonHelper requested before initialization");
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
public LinkData createCustomDungeonDoor(World world, int x, int y, int z)
|
|
{
|
|
//Create a link above the specified position. Link to a new pocket dimension.
|
|
LinkData link = new LinkData(world.provider.dimensionId, 0, x, y + 1, z, x, y + 1, z, true, 3);
|
|
link = dimHelper.instance.createPocket(link, true, false);
|
|
|
|
//Place a Warp Door linked to that pocket
|
|
itemDimDoor.placeDoorBlock(world, x, y, z, 3, mod_pocketDim.ExitDoor);
|
|
|
|
//Register the pocket as a custom dungeon
|
|
customDungeonStatus.put(link.destDimID,
|
|
dimHelper.instance.getLinkDataFromCoords(link.destXCoord, link.destYCoord, link.destZCoord, link.destDimID));
|
|
|
|
return link;
|
|
}
|
|
|
|
public boolean isCustomDungeon(int dimensionID)
|
|
{
|
|
return customDungeonStatus.containsKey(dimensionID);
|
|
}
|
|
|
|
public boolean validateDungeonType(String type)
|
|
{
|
|
//Check if the dungeon type is valid
|
|
return dungeonTypeChecker.contains(type.toLowerCase());
|
|
}
|
|
|
|
public boolean validateSchematicName(String name)
|
|
{
|
|
String[] dungeonData;
|
|
|
|
if (!name.endsWith(SCHEMATIC_FILE_EXTENSION))
|
|
return false;
|
|
|
|
dungeonData = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length()).split("_");
|
|
|
|
//Check for a valid number of parts
|
|
if (dungeonData.length < 3 || dungeonData.length > 4)
|
|
return false;
|
|
|
|
//Check if the dungeon type is valid
|
|
if (!dungeonTypeChecker.contains(dungeonData[0].toLowerCase()))
|
|
return false;
|
|
|
|
//Check if the name is valid
|
|
if (!SchematicNamePattern.matcher(dungeonData[1]).matches())
|
|
return false;
|
|
|
|
//Check if the open/closed flag is present
|
|
if (!dungeonData[2].equalsIgnoreCase("open") && !dungeonData[2].equalsIgnoreCase("closed"))
|
|
return false;
|
|
|
|
//If the weight is present, check that it is valid
|
|
if (dungeonData.length == 4)
|
|
{
|
|
try
|
|
{
|
|
int weight = Integer.parseInt(dungeonData[3]);
|
|
if (weight < 0 || weight > MAX_DUNGEON_WEIGHT)
|
|
return false;
|
|
}
|
|
catch (NumberFormatException e)
|
|
{
|
|
//Not a number
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void registerCustomDungeon(File schematicFile)
|
|
{
|
|
String name = schematicFile.getName();
|
|
String path = schematicFile.getAbsolutePath();
|
|
try
|
|
{
|
|
if (validateSchematicName(name))
|
|
{
|
|
//Strip off the file extension while splitting the file name
|
|
String[] dungeonData = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length()).split("_");
|
|
|
|
String dungeonType = dungeonData[0].toLowerCase();
|
|
boolean isOpen = dungeonData[2].equalsIgnoreCase("open");
|
|
int weight = (dungeonData.length == 4) ? Integer.parseInt(dungeonData[3]) : DEFAULT_DUNGEON_WEIGHT;
|
|
|
|
//Add this custom dungeon to the list corresponding to its type
|
|
DungeonGenerator generator = new DungeonGenerator(weight, path, isOpen);
|
|
|
|
dungeonTypeMapping.get(dungeonType).add(generator);
|
|
registeredDungeons.add(generator);
|
|
customDungeons.add(generator);
|
|
System.out.println("Imported " + name);
|
|
}
|
|
else
|
|
{
|
|
System.out.println("Could not parse dungeon filename, not adding dungeon to generation lists");
|
|
customDungeons.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, path, true));
|
|
System.out.println("Imported " + name);
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
System.out.println("Failed to import " + name);
|
|
}
|
|
}
|
|
|
|
public void importCustomDungeons(String path)
|
|
{
|
|
File directory = new File(path);
|
|
File[] schematicNames = directory.listFiles();
|
|
|
|
if (schematicNames != null)
|
|
{
|
|
for (File schematicFile: schematicNames)
|
|
{
|
|
if (schematicFile.getName().endsWith(SCHEMATIC_FILE_EXTENSION))
|
|
{
|
|
registerCustomDungeon(schematicFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void registerFlipBlocks()
|
|
{
|
|
metadataFlipList.add(Block.dispenser.blockID);
|
|
metadataFlipList.add(Block.stairsStoneBrick.blockID);
|
|
metadataFlipList.add(Block.lever.blockID);
|
|
metadataFlipList.add(Block.stoneButton.blockID);
|
|
metadataFlipList.add(Block.redstoneRepeaterIdle.blockID);
|
|
metadataFlipList.add(Block.redstoneRepeaterActive.blockID);
|
|
metadataFlipList.add(Block.tripWireSource.blockID);
|
|
metadataFlipList.add(Block.torchWood.blockID);
|
|
metadataFlipList.add(Block.torchRedstoneIdle.blockID);
|
|
metadataFlipList.add(Block.torchRedstoneActive.blockID);
|
|
metadataFlipList.add(Block.doorIron.blockID);
|
|
metadataFlipList.add(Block.doorWood.blockID);
|
|
metadataFlipList.add(Block.pistonBase.blockID);
|
|
metadataFlipList.add(Block.pistonStickyBase.blockID);
|
|
metadataFlipList.add(Block.pistonExtension.blockID);
|
|
metadataFlipList.add(Block.redstoneComparatorIdle.blockID);
|
|
metadataFlipList.add(Block.redstoneComparatorActive.blockID);
|
|
metadataFlipList.add(Block.signPost.blockID);
|
|
metadataFlipList.add(Block.signWall.blockID);
|
|
metadataFlipList.add(Block.skull.blockID);
|
|
metadataFlipList.add(Block.ladder.blockID);
|
|
metadataFlipList.add(Block.vine.blockID);
|
|
metadataFlipList.add(Block.anvil.blockID);
|
|
metadataFlipList.add(Block.chest.blockID);
|
|
metadataFlipList.add(Block.chestTrapped.blockID);
|
|
metadataFlipList.add(Block.hopperBlock.blockID);
|
|
metadataFlipList.add(Block.stairsNetherBrick.blockID);
|
|
metadataFlipList.add(Block.stairsCobblestone.blockID);
|
|
metadataFlipList.add(Block.stairsNetherBrick.blockID);
|
|
metadataFlipList.add(Block.stairsNetherQuartz.blockID);
|
|
metadataFlipList.add(Block.stairsSandStone.blockID);
|
|
|
|
metadataNextList.add(Block.redstoneRepeaterIdle.blockID);
|
|
metadataNextList.add(Block.redstoneRepeaterActive.blockID);
|
|
}
|
|
|
|
public void registerBaseDungeons()
|
|
{
|
|
hubs.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/4WayBasicHall.schematic", false));
|
|
hubs.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/4WayHallExit.schematic", false));
|
|
hubs.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/doorTotemRuins.schematic", true));
|
|
hubs.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/hallwayTrapRooms1.schematic", false));
|
|
hubs.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/longDoorHallway.schematic", false));
|
|
hubs.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallRotundaWithExit.schematic", false));
|
|
hubs.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/fortRuins.schematic", true));
|
|
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/collapsedSingleTunnel1.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/singleStraightHall1.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallBranchWithExit.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallSimpleLeft.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallSimpleRight.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleStairsUp.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleStairsDown.schematic", false));
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleSmallT1.schematic", false));
|
|
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/tntPuzzleTrap.schematic", false));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/brokenPillarsO.schematic", true));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/buggyTopEntry1.schematic", true));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/exitRuinsWithHiddenDoor.schematic", true));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/hallwayHiddenTreasure.schematic", false));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/mediumPillarStairs.schematic", true));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/ruinsO.schematic", true));
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/pitStairs.schematic", true));
|
|
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/azersDungeonO.schematic", false));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/diamondTowerTemple1.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/fallingTrapO.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/hiddenStaircaseO.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/lavaTrapO.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/randomTree.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallHiddenTowerO.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallSilverfishRoom.schematic", false));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/tntTrapO.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallDesert.schematic", true));
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallPond.schematic", true));
|
|
|
|
pistonTraps.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/hallwayPitFallTrap.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/pistonFloorHall.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/wallFallcomboPistonHall.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/fakeTNTTrap.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/pistonFallRuins.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/pistonSmasherHall.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleDropHall.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/fallingTNThall.schematic", false));
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/lavaPyramid.schematic", true));
|
|
|
|
mazes.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallMaze1.schematic", false));
|
|
mazes.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallMultilevelMaze.schematic", false));
|
|
|
|
exits.add(new DungeonGenerator(2 * DEFAULT_DUNGEON_WEIGHT, "/schematics/lockingExitHall.schematic", false));
|
|
exits.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/exitCube.schematic", true));
|
|
exits.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/smallExitPrison.schematic", true));
|
|
|
|
registeredDungeons.addAll(simpleHalls);
|
|
registeredDungeons.addAll(exits);
|
|
registeredDungeons.addAll(pistonTraps);
|
|
registeredDungeons.addAll(mazes);
|
|
registeredDungeons.addAll(deadEnds);
|
|
registeredDungeons.addAll(complexHalls);
|
|
registeredDungeons.addAll(hubs);
|
|
}
|
|
|
|
public boolean exportDungeon(World world, int centerX, int centerY, int centerZ, String exportPath)
|
|
{
|
|
int xMin, yMin, zMin;
|
|
int xMax, yMax, zMax;
|
|
int xStart, yStart, zStart;
|
|
int xEnd, yEnd, zEnd;
|
|
|
|
//Find the smallest bounding box that contains all non-air blocks within a max radius around the player.
|
|
xMax = yMax = zMax = Integer.MIN_VALUE;
|
|
xMin = yMin = zMin = Integer.MAX_VALUE;
|
|
|
|
xStart = centerX - MAX_EXPORT_RADIUS;
|
|
zStart = centerZ - MAX_EXPORT_RADIUS;
|
|
yStart = Math.max(centerY - MAX_EXPORT_RADIUS, 0);
|
|
|
|
xEnd = centerX + MAX_EXPORT_RADIUS;
|
|
zEnd = centerZ + MAX_EXPORT_RADIUS;
|
|
yEnd = Math.min(centerY + MAX_EXPORT_RADIUS, world.getActualHeight());
|
|
|
|
//This could be done more efficiently, but honestly, this is the simplest approach and it
|
|
//makes it easy for us to verify that the code is correct.
|
|
for (int y = yStart; y <= yEnd; y++)
|
|
{
|
|
for (int z = zStart; z <= zEnd; z++)
|
|
{
|
|
for (int x = xStart; x <= xEnd; x++)
|
|
{
|
|
if (!world.isAirBlock(x, y, z))
|
|
{
|
|
xMax = x > xMax ? x : xMax;
|
|
zMax = z > zMax ? z : zMax;
|
|
yMax = y > yMax ? y : yMax;
|
|
|
|
xMin = x < xMin ? x : xMin;
|
|
zMin = z < zMin ? z : zMin;
|
|
yMin = y < yMin ? y : yMin;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Export all the blocks within our selected bounding box
|
|
short width = (short) (xMax - xMin + 1);
|
|
short height = (short) (yMax - yMin + 1);
|
|
short length = (short) (zMax - zMin + 1);
|
|
|
|
byte[] blocks = new byte[width * height * length];
|
|
byte[] addBlocks = null;
|
|
byte[] blockData = new byte[width * height * length];
|
|
NBTTagList tileEntities = new NBTTagList();
|
|
|
|
for (int y = 0; y < height; y++)
|
|
{
|
|
for (int z = 0; z < length; z++)
|
|
{
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
int index = y * width * length + z * width + x;
|
|
int blockID = world.getBlockId(x + xMin, y + yMin, z + zMin);
|
|
int metadata = world.getBlockMetadata(x + xMin, y + yMin, z + zMin);
|
|
boolean changed = false;
|
|
|
|
if (blockID == properties.DimensionalDoorID)
|
|
{
|
|
blockID = Block.doorIron.blockID;
|
|
changed = true;
|
|
}
|
|
if (blockID == properties.WarpDoorID)
|
|
{
|
|
blockID = Block.doorWood.blockID;
|
|
changed = true;
|
|
}
|
|
//Map fabric of reality and permafabric blocks to standard export IDs
|
|
if (blockID == properties.FabricBlockID)
|
|
{
|
|
blockID = FABRIC_OF_REALITY_EXPORT_ID;
|
|
changed = true;
|
|
}
|
|
if (blockID == properties.PermaFabricBlockID)
|
|
{
|
|
blockID = PERMAFABRIC_EXPORT_ID;
|
|
changed = true;
|
|
}
|
|
|
|
// Save 4096 IDs in an AddBlocks section
|
|
if (blockID > 255)
|
|
{
|
|
if (addBlocks == null)
|
|
{
|
|
//Lazily create section
|
|
addBlocks = new byte[(blocks.length >> 1) + 1];
|
|
}
|
|
|
|
addBlocks[index >> 1] = (byte) (((index & 1) == 0) ?
|
|
addBlocks[index >> 1] & 0xF0 | (blockID >> 8) & 0xF
|
|
: addBlocks[index >> 1] & 0xF | ((blockID >> 8) & 0xF) << 4);
|
|
}
|
|
|
|
blocks[index] = (byte) blockID;
|
|
blockData[index] = (byte) metadata;
|
|
|
|
//Obtain and export the tile entity of the current block, if any.
|
|
//Do not obtain a tile entity if the block was changed from its original ID.
|
|
//I'm not sure if this approach is the most efficient but it works. ~SenseiKiwi
|
|
TileEntity tileEntity = !changed ? world.getBlockTileEntity(x + xMin, y + yMin, z + zMin) : null;
|
|
|
|
if (tileEntity != null)
|
|
{
|
|
//Get the tile entity's description as a compound NBT tag
|
|
NBTTagCompound entityData = new NBTTagCompound();
|
|
tileEntity.writeToNBT(entityData);
|
|
//Change the tile entity's location to the schematic coordinate system
|
|
entityData.setInteger("x", x);
|
|
entityData.setInteger("y", y);
|
|
entityData.setInteger("z", z);
|
|
|
|
tileEntities.appendTag(entityData);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Write NBT tags for schematic file
|
|
NBTTagCompound schematicTag = new NBTTagCompound("Schematic");
|
|
|
|
schematicTag.setShort("Width", width);
|
|
schematicTag.setShort("Length", length);
|
|
schematicTag.setShort("Height", height);
|
|
|
|
schematicTag.setByteArray("Blocks", blocks);
|
|
schematicTag.setByteArray("Data", blockData);
|
|
|
|
schematicTag.setTag("Entities", new NBTTagList());
|
|
schematicTag.setTag("TileEntities", tileEntities);
|
|
schematicTag.setString("Materials", "Alpha");
|
|
|
|
if (addBlocks != null)
|
|
{
|
|
schematicTag.setByteArray("AddBlocks", addBlocks);
|
|
}
|
|
|
|
//Write schematic data to a file
|
|
try
|
|
{
|
|
FileOutputStream outputStream = new FileOutputStream(new File(exportPath));
|
|
CompressedStreamTools.writeCompressed(schematicTag, outputStream);
|
|
//writeCompressed() probably closes the stream on its own - call close again just in case.
|
|
//Closing twice will not throw an exception.
|
|
outputStream.close();
|
|
return true;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void generateDungeonLink(LinkData incoming)
|
|
{
|
|
DungeonGenerator dungeon;
|
|
int depth = dimHelper.instance.getDimDepth(incoming.locDimID);
|
|
int depthWeight = rand.nextInt(depth + 2) + rand.nextInt(depth + 2) - 2;
|
|
|
|
|
|
int count = 10;
|
|
boolean flag = true;
|
|
try
|
|
{
|
|
|
|
if (incoming.destYCoord > 15)
|
|
{
|
|
do
|
|
{
|
|
count--;
|
|
flag = true;
|
|
//Select a dungeon at random, taking into account its weight
|
|
dungeon = getRandomDungeon(rand, registeredDungeons);
|
|
|
|
if (depth <= 1)
|
|
{
|
|
if(rand.nextBoolean())
|
|
{
|
|
dungeon = complexHalls.get(rand.nextInt(complexHalls.size()));
|
|
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
|
|
}
|
|
else if(deadEnds.contains(dungeon)||exits.contains(dungeon))
|
|
{
|
|
flag=false;
|
|
}
|
|
}
|
|
else if (depth <= 3 && (deadEnds.contains(dungeon) || exits.contains(dungeon) || rand.nextBoolean()))
|
|
{
|
|
if(rand.nextBoolean())
|
|
{
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = mazes.get(rand.nextInt(mazes.size()));
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
|
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
else if (rand.nextInt(3) == 0 && !complexHalls.contains(dungeon))
|
|
{
|
|
if (rand.nextInt(3) == 0)
|
|
{
|
|
dungeon = simpleHalls.get(rand.nextInt(simpleHalls.size()));
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
|
}
|
|
else if (depth < 4)
|
|
{
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
}
|
|
}
|
|
else if (depthWeight - depthWeight / 2 > depth -4 && (deadEnds.contains(dungeon) || exits.contains(dungeon)))
|
|
{
|
|
if(rand.nextBoolean())
|
|
{
|
|
dungeon = simpleHalls.get(rand.nextInt(simpleHalls.size()));
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = complexHalls.get(rand.nextInt(complexHalls.size()));
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
else if (depthWeight > 7 && hubs.contains(dungeon))
|
|
{
|
|
if(rand.nextInt(12)+5<depthWeight)
|
|
{
|
|
if(rand.nextBoolean())
|
|
{
|
|
dungeon = exits.get(rand.nextInt(exits.size()));
|
|
}
|
|
else if(rand.nextBoolean())
|
|
{
|
|
dungeon = deadEnds.get(rand.nextInt(deadEnds.size()));
|
|
}
|
|
else
|
|
{
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
}
|
|
}
|
|
else if (depth > 10 && hubs.contains(dungeon))
|
|
{
|
|
flag = false;
|
|
}
|
|
|
|
if(getDungeonDataInChain(dimHelper.dimList.get(incoming.locDimID)).contains(dungeon))
|
|
{
|
|
flag=false;
|
|
}
|
|
}
|
|
while (!flag && count > 0);
|
|
}
|
|
else
|
|
{
|
|
dungeon = defaultUp;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
if (registeredDungeons.size() > 0)
|
|
{
|
|
//Select a random dungeon
|
|
dungeon = getRandomDungeon(rand, registeredDungeons);
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
dimHelper.dimList.get(incoming.destDimID).dungeonGenerator = dungeon;
|
|
}
|
|
|
|
public Collection<String> getDungeonNames() {
|
|
|
|
//Use a HashSet to guarantee that all dungeon names will be distinct.
|
|
//This shouldn't be necessary if we keep proper lists without repetitions,
|
|
//but it's a fool-proof workaround.
|
|
HashSet<String> dungeonNames = new HashSet<String>();
|
|
dungeonNames.addAll( parseDungeonNames(registeredDungeons) );
|
|
dungeonNames.addAll( parseDungeonNames(customDungeons) );
|
|
|
|
//Sort dungeon names alphabetically
|
|
ArrayList<String> sortedNames = new ArrayList<String>(dungeonNames);
|
|
Collections.sort(sortedNames);
|
|
return sortedNames;
|
|
}
|
|
|
|
private static ArrayList<String> parseDungeonNames(ArrayList<DungeonGenerator> dungeons)
|
|
{
|
|
String name;
|
|
File schematic;
|
|
ArrayList<String> names = new ArrayList<String>(dungeons.size());
|
|
|
|
for (DungeonGenerator dungeon : dungeons)
|
|
{
|
|
//Retrieve the file name and strip off the file extension
|
|
schematic = new File(dungeon.schematicPath);
|
|
name = schematic.getName();
|
|
name = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length());
|
|
names.add(name);
|
|
}
|
|
return names;
|
|
}
|
|
|
|
private static DungeonGenerator getRandomDungeon(Random random, Collection<DungeonGenerator> dungeons)
|
|
{
|
|
//Use Minecraft's WeightedRandom to select our dungeon. =D
|
|
ArrayList<WeightedContainer<DungeonGenerator>> weights =
|
|
new ArrayList<WeightedContainer<DungeonGenerator>>(dungeons.size());
|
|
for (DungeonGenerator dungeon : dungeons)
|
|
{
|
|
weights.add(new WeightedContainer<DungeonGenerator>(dungeon, dungeon.weight));
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
WeightedContainer<DungeonGenerator> resultContainer = (WeightedContainer<DungeonGenerator>) WeightedRandom.getRandomItem(random, weights);
|
|
return (resultContainer != null) ? resultContainer.getData() : null;
|
|
}
|
|
public static ArrayList<DungeonGenerator> getDungeonDataInChain(DimData dimData)
|
|
{
|
|
DimData startingDim = dimHelper.dimList.get(dimHelper.instance.getLinkDataFromCoords(dimData.exitDimLink.destXCoord, dimData.exitDimLink.destYCoord, dimData.exitDimLink.destZCoord, dimData.exitDimLink.destDimID).destDimID);
|
|
|
|
return getDungeonDataBelow(startingDim);
|
|
}
|
|
private static ArrayList<DungeonGenerator> getDungeonDataBelow(DimData dimData)
|
|
{
|
|
ArrayList<DungeonGenerator> dungeonData = new ArrayList<DungeonGenerator>();
|
|
if(dimData.dungeonGenerator!=null)
|
|
{
|
|
dungeonData.add(dimData.dungeonGenerator);
|
|
|
|
for(LinkData link : dimData.getLinksInDim())
|
|
{
|
|
if(dimHelper.dimList.containsKey(link.destDimID))
|
|
{
|
|
if(dimHelper.dimList.get(link.destDimID).dungeonGenerator!=null&&dimHelper.instance.getDimDepth(link.destDimID)==dimData.depth+1)
|
|
{
|
|
for(DungeonGenerator dungeonGen :getDungeonDataBelow(dimHelper.dimList.get(link.destDimID)) )
|
|
{
|
|
if(!dungeonData.contains(dungeonGen))
|
|
{
|
|
dungeonData.add(dungeonGen);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return dungeonData;
|
|
}
|
|
} |