2013-06-10 23:03:52 +02:00
|
|
|
package StevenDimDoors.mod_pocketDim.helpers;
|
|
|
|
|
|
|
|
import java.io.File;
|
|
|
|
import java.util.ArrayList;
|
2013-06-17 12:18:15 +02:00
|
|
|
import java.util.Collection;
|
2013-06-17 12:31:53 +02:00
|
|
|
import java.util.Collections;
|
2013-06-10 23:03:52 +02:00
|
|
|
import java.util.HashMap;
|
2013-06-15 17:21:49 +02:00
|
|
|
import java.util.HashSet;
|
2013-06-10 23:03:52 +02:00
|
|
|
import java.util.Random;
|
2013-06-15 16:25:50 +02:00
|
|
|
import java.util.regex.Pattern;
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-18 04:26:39 +02:00
|
|
|
import net.minecraft.util.WeightedRandom;
|
2013-06-10 23:03:52 +02:00
|
|
|
import net.minecraft.world.World;
|
2013-06-14 01:01:54 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.DDProperties;
|
2013-07-13 05:40:21 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.DimData;
|
2013-06-11 20:42:11 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.DungeonGenerator;
|
2013-06-10 23:03:52 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.LinkData;
|
|
|
|
import StevenDimDoors.mod_pocketDim.mod_pocketDim;
|
2013-07-29 15:58:47 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.dungeon.DungeonSchematic;
|
2013-06-18 16:23:31 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.items.itemDimDoor;
|
2013-06-18 04:26:39 +02:00
|
|
|
import StevenDimDoors.mod_pocketDim.util.WeightedContainer;
|
2013-06-10 23:03:52 +02:00
|
|
|
|
|
|
|
public class DungeonHelper
|
|
|
|
{
|
2013-06-16 07:00:05 +02:00
|
|
|
private static DungeonHelper instance = null;
|
2013-06-14 01:01:54 +02:00
|
|
|
private static DDProperties properties = null;
|
2013-06-25 19:55:13 +02:00
|
|
|
public static final Pattern SchematicNamePattern = Pattern.compile("[A-Za-z0-9_\\-]+");
|
|
|
|
public static final Pattern DungeonNamePattern = Pattern.compile("[A-Za-z0-9\\-]+");
|
2013-06-15 17:21:49 +02:00
|
|
|
|
2013-06-25 19:55:13 +02:00
|
|
|
public static final String SCHEMATIC_FILE_EXTENSION = ".schematic";
|
2013-06-15 16:25:50 +02:00
|
|
|
private static final int DEFAULT_DUNGEON_WEIGHT = 100;
|
2013-06-25 19:55:13 +02:00
|
|
|
public static final int MAX_DUNGEON_WEIGHT = 10000; //Used to prevent overflows and math breaking down
|
2013-07-15 06:47:32 +02:00
|
|
|
private static final int MAX_EXPORT_RADIUS = 50;
|
2013-07-31 14:05:58 +02:00
|
|
|
public static final short MAX_DUNGEON_WIDTH = 2 * MAX_EXPORT_RADIUS + 1;
|
|
|
|
public static final short MAX_DUNGEON_HEIGHT = 2 * MAX_EXPORT_RADIUS + 1;
|
|
|
|
public static final short MAX_DUNGEON_LENGTH = 2 * MAX_EXPORT_RADIUS + 1;
|
2013-06-15 17:21:49 +02:00
|
|
|
|
2013-07-15 06:54:53 +02:00
|
|
|
public static final int FABRIC_OF_REALITY_EXPORT_ID = 1973;
|
|
|
|
public static final int PERMAFABRIC_EXPORT_ID = 220;
|
|
|
|
|
2013-06-15 17:21:49 +02:00
|
|
|
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();
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-15 14:07:33 +02:00
|
|
|
public ArrayList<DungeonGenerator> customDungeons = new ArrayList<DungeonGenerator>();
|
|
|
|
public ArrayList<DungeonGenerator> registeredDungeons = new ArrayList<DungeonGenerator>();
|
2013-06-15 14:46:28 +02:00
|
|
|
|
|
|
|
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>();
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-19 04:39:03 +02:00
|
|
|
public DungeonGenerator defaultBreak = new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/somethingBroke.schematic", true);
|
|
|
|
public DungeonGenerator defaultUp = new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/simpleStairsUp.schematic", true);
|
2013-06-16 08:59:02 +02:00
|
|
|
|
2013-06-15 17:21:49 +02:00
|
|
|
private HashSet<String> dungeonTypeChecker;
|
2013-06-16 17:06:08 +02:00
|
|
|
private HashMap<String, ArrayList<DungeonGenerator>> dungeonTypeMapping;
|
2013-06-15 17:21:49 +02:00
|
|
|
|
2013-06-16 07:00:05 +02:00
|
|
|
private DungeonHelper()
|
2013-06-15 14:46:28 +02:00
|
|
|
{
|
2013-06-15 17:21:49 +02:00
|
|
|
//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
|
2013-06-22 20:27:59 +02:00
|
|
|
//Dungeon type names must be passed in lowercase to make matching easier.
|
2013-06-16 17:06:08 +02:00
|
|
|
dungeonTypeMapping = new HashMap<String, ArrayList<DungeonGenerator>>();
|
2013-06-22 20:27:59 +02:00
|
|
|
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);
|
2013-06-15 17:21:49 +02:00
|
|
|
|
|
|
|
//Load our reference to the DDProperties singleton
|
2013-06-15 14:46:28 +02:00
|
|
|
if (properties == null)
|
|
|
|
properties = DDProperties.instance();
|
2013-06-16 07:13:06 +02:00
|
|
|
|
2013-06-18 16:23:31 +02:00
|
|
|
registerCustomDungeons();
|
2013-06-16 07:13:06 +02:00
|
|
|
}
|
|
|
|
|
2013-06-18 16:23:31 +02:00
|
|
|
private void registerCustomDungeons()
|
2013-06-16 07:13:06 +02:00
|
|
|
{
|
|
|
|
File file = new File(properties.CustomSchematicDirectory);
|
2013-06-16 16:54:03 +02:00
|
|
|
if (file.exists() || file.mkdir())
|
2013-06-16 07:13:06 +02:00
|
|
|
{
|
2013-06-20 10:47:16 +02:00
|
|
|
copyfile.copyFile("/mods/DimDoors/text/How_to_add_dungeons.txt", file.getAbsolutePath() + "/How_to_add_dungeons.txt");
|
2013-06-16 07:13:06 +02:00
|
|
|
}
|
|
|
|
importCustomDungeons(properties.CustomSchematicDirectory);
|
|
|
|
registerBaseDungeons();
|
2013-06-15 14:46:28 +02:00
|
|
|
}
|
|
|
|
|
2013-06-16 18:06:21 +02:00
|
|
|
public static DungeonHelper initialize()
|
2013-06-16 07:00:05 +02:00
|
|
|
{
|
|
|
|
if (instance == null)
|
2013-06-16 07:13:06 +02:00
|
|
|
{
|
2013-06-16 07:00:05 +02:00
|
|
|
instance = new DungeonHelper();
|
2013-06-16 07:13:06 +02:00
|
|
|
}
|
2013-06-16 07:00:05 +02:00
|
|
|
else
|
2013-06-16 07:13:06 +02:00
|
|
|
{
|
2013-06-16 18:06:21 +02:00
|
|
|
throw new IllegalStateException("Cannot initialize DungeonHelper twice");
|
2013-06-16 07:13:06 +02:00
|
|
|
}
|
2013-06-16 07:00:05 +02:00
|
|
|
|
|
|
|
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...
|
2013-06-16 18:06:21 +02:00
|
|
|
throw new IllegalStateException("Instance of DungeonHelper requested before initialization");
|
2013-06-16 07:00:05 +02:00
|
|
|
}
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
2013-06-18 16:23:31 +02:00
|
|
|
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);
|
|
|
|
|
|
|
|
return link;
|
|
|
|
}
|
|
|
|
|
2013-06-25 19:55:13 +02:00
|
|
|
public boolean validateDungeonType(String type)
|
|
|
|
{
|
|
|
|
//Check if the dungeon type is valid
|
|
|
|
return dungeonTypeChecker.contains(type.toLowerCase());
|
|
|
|
}
|
|
|
|
|
2013-06-15 16:25:50 +02:00
|
|
|
public boolean validateSchematicName(String name)
|
|
|
|
{
|
2013-06-22 20:27:59 +02:00
|
|
|
String[] dungeonData;
|
|
|
|
|
|
|
|
if (!name.endsWith(SCHEMATIC_FILE_EXTENSION))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
dungeonData = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length()).split("_");
|
2013-06-15 16:25:50 +02:00
|
|
|
|
|
|
|
//Check for a valid number of parts
|
|
|
|
if (dungeonData.length < 3 || dungeonData.length > 4)
|
|
|
|
return false;
|
|
|
|
|
2013-06-15 17:21:49 +02:00
|
|
|
//Check if the dungeon type is valid
|
|
|
|
if (!dungeonTypeChecker.contains(dungeonData[0].toLowerCase()))
|
2013-06-15 16:25:50 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
//Check if the name is valid
|
2013-06-25 19:55:13 +02:00
|
|
|
if (!SchematicNamePattern.matcher(dungeonData[1]).matches())
|
2013-06-15 16:25:50 +02:00
|
|
|
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]);
|
2013-06-15 17:30:05 +02:00
|
|
|
if (weight < 0 || weight > MAX_DUNGEON_WEIGHT)
|
2013-06-15 16:25:50 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch (NumberFormatException e)
|
|
|
|
{
|
|
|
|
//Not a number
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-06-10 23:03:52 +02:00
|
|
|
public void registerCustomDungeon(File schematicFile)
|
|
|
|
{
|
2013-06-15 16:25:50 +02:00
|
|
|
String name = schematicFile.getName();
|
2013-06-15 17:21:49 +02:00
|
|
|
String path = schematicFile.getAbsolutePath();
|
2013-06-10 23:03:52 +02:00
|
|
|
try
|
|
|
|
{
|
2013-06-22 20:27:59 +02:00
|
|
|
if (validateSchematicName(name))
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 16:25:50 +02:00
|
|
|
//Strip off the file extension while splitting the file name
|
|
|
|
String[] dungeonData = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length()).split("_");
|
|
|
|
|
2013-06-15 17:21:49 +02:00
|
|
|
String dungeonType = dungeonData[0].toLowerCase();
|
2013-06-22 20:27:59 +02:00
|
|
|
boolean isOpen = dungeonData[2].equalsIgnoreCase("open");
|
2013-06-15 16:25:50 +02:00
|
|
|
int weight = (dungeonData.length == 4) ? Integer.parseInt(dungeonData[3]) : DEFAULT_DUNGEON_WEIGHT;
|
2013-06-15 17:21:49 +02:00
|
|
|
|
|
|
|
//Add this custom dungeon to the list corresponding to its type
|
2013-06-22 20:27:59 +02:00
|
|
|
DungeonGenerator generator = new DungeonGenerator(weight, path, isOpen);
|
2013-06-15 16:25:50 +02:00
|
|
|
|
2013-06-15 17:21:49 +02:00
|
|
|
dungeonTypeMapping.get(dungeonType).add(generator);
|
|
|
|
registeredDungeons.add(generator);
|
2013-06-15 17:30:05 +02:00
|
|
|
customDungeons.add(generator);
|
2013-06-15 16:25:50 +02:00
|
|
|
System.out.println("Imported " + name);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
System.out.println("Could not parse dungeon filename, not adding dungeon to generation lists");
|
2013-06-15 17:21:49 +02:00
|
|
|
customDungeons.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, path, true));
|
2013-06-15 16:25:50 +02:00
|
|
|
System.out.println("Imported " + name);
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
catch(Exception e)
|
|
|
|
{
|
|
|
|
e.printStackTrace();
|
2013-06-15 16:25:50 +02:00
|
|
|
System.out.println("Failed to import " + name);
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
|
2013-06-17 12:31:53 +02:00
|
|
|
public void importCustomDungeons(String path)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-17 12:31:53 +02:00
|
|
|
File directory = new File(path);
|
|
|
|
File[] schematicNames = directory.listFiles();
|
2013-06-15 14:07:33 +02:00
|
|
|
|
2013-06-17 12:31:53 +02:00
|
|
|
if (schematicNames != null)
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
2013-06-17 12:31:53 +02:00
|
|
|
for (File schematicFile: schematicNames)
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
2013-06-17 12:31:53 +02:00
|
|
|
if (schematicFile.getName().endsWith(SCHEMATIC_FILE_EXTENSION))
|
|
|
|
{
|
|
|
|
registerCustomDungeon(schematicFile);
|
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void registerBaseDungeons()
|
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
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));
|
2013-07-17 07:45:41 +02:00
|
|
|
hubs.add(new DungeonGenerator(10, "/schematics/Hub_SK-Claustrophobia_Open_10.schematic", true));
|
|
|
|
hubs.add(new DungeonGenerator(50, "/schematics/Hub_SK-HeartOfDisorder_Open_50.schematic", true));
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
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));
|
2013-07-17 07:45:41 +02:00
|
|
|
simpleHalls.add(new DungeonGenerator(50, "/schematics/SimpleHall_SK-LeftDownStairs_Open_50.schematic", true));
|
|
|
|
simpleHalls.add(new DungeonGenerator(50, "/schematics/SimpleHall_SK-LeftUpPath_Open_50.schematic", true));
|
|
|
|
simpleHalls.add(new DungeonGenerator(50, "/schematics/SimpleHall_SK-RightDownStairs_Open_50.schematic", true));
|
|
|
|
simpleHalls.add(new DungeonGenerator(50, "/schematics/SimpleHall_SK-RightUpPath_Open_50.schematic", true));
|
|
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/SimpleHall_SK-SpiralHallway_Open_100.schematic", true));
|
2013-07-18 07:20:12 +02:00
|
|
|
simpleHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/complexHall_largeBrokenHall_closed_100.schematic", false));
|
|
|
|
|
2013-07-17 07:45:41 +02:00
|
|
|
|
2013-06-18 04:26:39 +02:00
|
|
|
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));
|
2013-07-17 07:45:41 +02:00
|
|
|
complexHalls.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/ComplexHall_SK-HiddenStairs_Open_100.schematic", true));
|
|
|
|
complexHalls.add(new DungeonGenerator(10, "/schematics/ComplexHall_SK-LostGarden_Open_10.schematic", true));
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/azersDungeonO.schematic", false));
|
|
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/diamondTowerTemple1.schematic", true));
|
2013-06-27 07:03:09 +02:00
|
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/fallingTrapO.schematic", true));
|
2013-06-18 04:26:39 +02:00
|
|
|
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));
|
2013-07-17 07:45:41 +02:00
|
|
|
deadEnds.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/DeadEnd_SK-FarAwayInTheDark_Open_100.schematic", true));
|
|
|
|
deadEnds.add(new DungeonGenerator(50, "/schematics/DeadEnd_SK-UnstableDesert_Open_50.schematic", true));
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
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));
|
2013-07-18 20:30:21 +02:00
|
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/pistonFallRuins.schematic", true));
|
2013-06-18 04:26:39 +02:00
|
|
|
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));
|
2013-07-17 07:45:41 +02:00
|
|
|
pistonTraps.add(new DungeonGenerator(10, "/schematics/Trap_SK-RestlessCorridor_Open_10.schematic", true));
|
2013-07-18 07:20:12 +02:00
|
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT, "/schematics/trap_pistonFloorPlatform_closed_100.schematic", false));
|
|
|
|
pistonTraps.add(new DungeonGenerator(DEFAULT_DUNGEON_WEIGHT/2, "/schematics/trap_pistonFloorPlatform2_closed_100.schematic", false));
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
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);
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
|
2013-07-15 07:58:01 +02:00
|
|
|
public boolean exportDungeon(World world, int centerX, int centerY, int centerZ, String exportPath)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-07-15 10:15:58 +02:00
|
|
|
//Write schematic data to a file
|
2013-06-15 14:07:33 +02:00
|
|
|
try
|
|
|
|
{
|
2013-07-29 15:58:47 +02:00
|
|
|
DungeonSchematic dungeon = DungeonSchematic.copyFromWorld(world,
|
2013-07-31 14:05:58 +02:00
|
|
|
centerX - MAX_EXPORT_RADIUS, centerY - MAX_EXPORT_RADIUS, centerZ - MAX_EXPORT_RADIUS,
|
|
|
|
MAX_DUNGEON_WIDTH, MAX_DUNGEON_HEIGHT, MAX_DUNGEON_LENGTH, true);
|
2013-07-30 19:58:14 +02:00
|
|
|
dungeon.applyExportFilters(properties);
|
2013-07-29 15:58:47 +02:00
|
|
|
dungeon.writeToFile(exportPath);
|
2013-06-16 11:59:53 +02:00
|
|
|
return true;
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
catch(Exception e)
|
|
|
|
{
|
|
|
|
e.printStackTrace();
|
2013-06-16 11:59:53 +02:00
|
|
|
return false;
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
|
2013-06-18 04:26:39 +02:00
|
|
|
public void generateDungeonLink(LinkData incoming)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-11 20:42:11 +02:00
|
|
|
DungeonGenerator dungeon;
|
2013-06-18 04:26:39 +02:00
|
|
|
int depth = dimHelper.instance.getDimDepth(incoming.locDimID);
|
|
|
|
int depthWeight = rand.nextInt(depth + 2) + rand.nextInt(depth + 2) - 2;
|
2013-06-15 14:07:33 +02:00
|
|
|
|
2013-06-16 20:40:26 +02:00
|
|
|
int count = 10;
|
2013-06-18 04:26:39 +02:00
|
|
|
boolean flag = true;
|
2013-06-10 23:03:52 +02:00
|
|
|
try
|
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
if (incoming.destYCoord > 15)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
do
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
count--;
|
|
|
|
flag = true;
|
2013-06-18 04:26:39 +02:00
|
|
|
//Select a dungeon at random, taking into account its weight
|
|
|
|
dungeon = getRandomDungeon(rand, registeredDungeons);
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-18 04:26:39 +02:00
|
|
|
if (depth <= 1)
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
|
|
|
if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = complexHalls.get(rand.nextInt(complexHalls.size()));
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
else if(rand.nextBoolean())
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
|
|
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
else if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
else if(deadEnds.contains(dungeon)||exits.contains(dungeon))
|
|
|
|
{
|
|
|
|
flag=false;
|
|
|
|
}
|
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (depth <= 3 && (deadEnds.contains(dungeon) || exits.contains(dungeon) || rand.nextBoolean()))
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
|
|
|
if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
else if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = mazes.get(rand.nextInt(mazes.size()));
|
|
|
|
}
|
|
|
|
else if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
2013-06-10 23:03:52 +02:00
|
|
|
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
flag = false;
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (rand.nextInt(3) == 0 && !complexHalls.contains(dungeon))
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
if (rand.nextInt(3) == 0)
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
|
|
|
dungeon = simpleHalls.get(rand.nextInt(simpleHalls.size()));
|
|
|
|
}
|
|
|
|
else if(rand.nextBoolean())
|
|
|
|
{
|
|
|
|
dungeon = pistonTraps.get(rand.nextInt(pistonTraps.size()));
|
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (depth < 4)
|
2013-06-15 14:07:33 +02:00
|
|
|
{
|
|
|
|
dungeon = hubs.get(rand.nextInt(hubs.size()));
|
|
|
|
}
|
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (depthWeight - depthWeight / 2 > depth -4 && (deadEnds.contains(dungeon) || exits.contains(dungeon)))
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
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
|
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
flag = false;
|
2013-06-15 14:07:33 +02:00
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (depthWeight > 7 && hubs.contains(dungeon))
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
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;
|
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
else if (depth > 10 && hubs.contains(dungeon))
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
flag = false;
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-07-13 20:13:01 +02:00
|
|
|
|
|
|
|
if(getDungeonDataInChain(dimHelper.dimList.get(incoming.locDimID)).contains(dungeon))
|
|
|
|
{
|
|
|
|
flag=false;
|
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
while (!flag && count > 0);
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
else
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-15 14:07:33 +02:00
|
|
|
dungeon = defaultUp;
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
catch (Exception e)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-16 20:40:26 +02:00
|
|
|
e.printStackTrace();
|
2013-06-18 04:26:39 +02:00
|
|
|
if (registeredDungeons.size() > 0)
|
2013-06-10 23:03:52 +02:00
|
|
|
{
|
2013-06-18 04:26:39 +02:00
|
|
|
//Select a random dungeon
|
|
|
|
dungeon = getRandomDungeon(rand, registeredDungeons);
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2013-06-15 14:07:33 +02:00
|
|
|
dimHelper.dimList.get(incoming.destDimID).dungeonGenerator = dungeon;
|
2013-07-31 18:09:47 +02:00
|
|
|
//dimHelper.dimList.get(incoming.destDimID).dungeonGenerator = defaultUp;
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|
2013-06-17 12:18:15 +02:00
|
|
|
|
|
|
|
public Collection<String> getDungeonNames() {
|
2013-06-17 12:31:53 +02:00
|
|
|
|
2013-06-17 12:18:15 +02:00
|
|
|
//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) );
|
2013-06-17 12:31:53 +02:00
|
|
|
|
|
|
|
//Sort dungeon names alphabetically
|
|
|
|
ArrayList<String> sortedNames = new ArrayList<String>(dungeonNames);
|
|
|
|
Collections.sort(sortedNames);
|
|
|
|
return sortedNames;
|
2013-06-17 12:18:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private static ArrayList<String> parseDungeonNames(ArrayList<DungeonGenerator> dungeons)
|
|
|
|
{
|
|
|
|
String name;
|
|
|
|
File schematic;
|
|
|
|
ArrayList<String> names = new ArrayList<String>(dungeons.size());
|
|
|
|
|
|
|
|
for (DungeonGenerator dungeon : dungeons)
|
|
|
|
{
|
2013-06-17 12:34:35 +02:00
|
|
|
//Retrieve the file name and strip off the file extension
|
2013-06-17 12:18:15 +02:00
|
|
|
schematic = new File(dungeon.schematicPath);
|
|
|
|
name = schematic.getName();
|
|
|
|
name = name.substring(0, name.length() - SCHEMATIC_FILE_EXTENSION.length());
|
|
|
|
names.add(name);
|
|
|
|
}
|
|
|
|
return names;
|
|
|
|
}
|
2013-06-18 04:26:39 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2013-07-13 20:13:01 +02:00
|
|
|
public static ArrayList<DungeonGenerator> getDungeonDataInChain(DimData dimData)
|
2013-07-13 05:40:21 +02:00
|
|
|
{
|
|
|
|
DimData startingDim = dimHelper.dimList.get(dimHelper.instance.getLinkDataFromCoords(dimData.exitDimLink.destXCoord, dimData.exitDimLink.destYCoord, dimData.exitDimLink.destZCoord, dimData.exitDimLink.destDimID).destDimID);
|
|
|
|
|
2013-07-13 20:13:01 +02:00
|
|
|
return getDungeonDataBelow(startingDim);
|
2013-07-13 05:40:21 +02:00
|
|
|
}
|
2013-07-13 20:13:01 +02:00
|
|
|
private static ArrayList<DungeonGenerator> getDungeonDataBelow(DimData dimData)
|
2013-07-13 05:40:21 +02:00
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
2013-07-13 20:13:01 +02:00
|
|
|
for(DungeonGenerator dungeonGen :getDungeonDataBelow(dimHelper.dimList.get(link.destDimID)) )
|
2013-07-13 05:40:21 +02:00
|
|
|
{
|
|
|
|
if(!dungeonData.contains(dungeonGen))
|
|
|
|
{
|
|
|
|
dungeonData.add(dungeonGen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dungeonData;
|
|
|
|
}
|
2013-06-10 23:03:52 +02:00
|
|
|
}
|