Repo-Mirror/Iris-World-Engine
9
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-12-19 15:09:18 +00:00
Code Issues Releases Activity

Matter apis

Browse Source
This commit is contained in:
Daniel Mills
2021-08-04 19:27:28 -04:00
parent 6e369ea787
commit f2b301cb17
207 changed files with 1381 additions and 2386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/main/java/com/volmit/iris/Iris.java
View File

@@ -29,10 +29,10 @@ import com.volmit.iris.core.nms.INMS;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.EngineCompositeGenerator;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomeCustom;
import com.volmit.iris.engine.object.compat.IrisCompat;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.parallel.MultiBurst;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KSet;
@@ -182,7 +182,7 @@ public class Iris extends VolmitPlugin implements Listener {
if (dims.exists()) {
for (File j : dims.listFiles()) {
if (j.getName().endsWith(".json")) {
LoaderDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
Iris.verbose(" Checking Dimension " + dim.getLoadFile().getPath());
if (dim.installDataPack(() -> data, dpacks)) {
reboot = true;
@@ -305,7 +305,7 @@ public class Iris extends VolmitPlugin implements Listener {
if (dims.exists()) {
for (File j : dims.listFiles()) {
if (j.getName().endsWith(".json")) {
LoaderDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
if (!verifyDataPackInstalled(dim)) {
bad = true;
@@ -335,12 +335,12 @@ public class Iris extends VolmitPlugin implements Listener {
}
}
public boolean verifyDataPackInstalled(LoaderDimension dimension) {
public boolean verifyDataPackInstalled(IrisDimension dimension) {
IrisData idm = new IrisData(getDataFolder("packs", dimension.getLoadKey()));
KSet<String> keys = new KSet<>();
boolean warn = false;
for (LoaderBiome i : dimension.getAllBiomes(() -> idm)) {
for (IrisBiome i : dimension.getAllBiomes(() -> idm)) {
if (i.isCustom()) {
for (IrisBiomeCustom j : i.getCustomDerivitives()) {
keys.add(dimension.getLoadKey() + ":" + j.getId());

30
src/main/java/com/volmit/iris/core/ConversionManager.java
View File

@@ -20,18 +20,18 @@ package com.volmit.iris.core;
import com.google.gson.Gson;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.mca.NBTWorld;
import com.volmit.iris.engine.data.nbt.io.NBTUtil;
import com.volmit.iris.engine.data.nbt.io.NamedTag;
import com.volmit.iris.engine.data.nbt.tag.CompoundTag;
import com.volmit.iris.engine.data.nbt.tag.IntTag;
import com.volmit.iris.engine.data.nbt.tag.ListTag;
import com.volmit.iris.util.nbt.mca.NBTWorld;
import com.volmit.iris.util.nbt.io.NBTUtil;
import com.volmit.iris.util.nbt.io.NamedTag;
import com.volmit.iris.util.nbt.tag.CompoundTag;
import com.volmit.iris.util.nbt.tag.IntTag;
import com.volmit.iris.util.nbt.tag.ListTag;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPieceConnector;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPool;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPool;
import com.volmit.iris.engine.object.objects.IrisDirection;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.format.Form;
@@ -105,7 +105,7 @@ public class ConversionManager {
}
public void convertStructures(File in, File out, VolmitSender s) {
KMap<String, LoaderJigsawPool> pools = new KMap<>();
KMap<String, IrisJigsawPool> pools = new KMap<>();
KList<File> roots = new KList<>();
AtomicInteger total = new AtomicInteger(0);
AtomicInteger at = new AtomicInteger(0);
@@ -123,7 +123,7 @@ public class ConversionManager {
b = b.substring(0, b.length() - 1);
}
pools.put(b, new LoaderJigsawPool());
pools.put(b, new IrisJigsawPool());
}
});
findAllNBT(in, (folder, file) -> {
@@ -136,7 +136,7 @@ public class ConversionManager {
if (b.endsWith("/")) {
b = b.substring(0, b.length() - 1);
}
LoaderJigsawPool jpool = pools.get(b);
IrisJigsawPool jpool = pools.get(b);
File destObjects = new File(out.getAbsolutePath() + "/objects/" + in.toURI().relativize(folder.toURI()).getPath());
File destPieces = new File(out.getAbsolutePath() + "/jigsaw-pieces/" + in.toURI().relativize(folder.toURI()).getPath());
destObjects.mkdirs();
@@ -158,8 +158,8 @@ public class ConversionManager {
CompoundTag cp = paletteList.get(i);
palette.add(NBTWorld.getBlockData(cp));
}
LoaderJigsawPiece piece = new LoaderJigsawPiece();
LoaderObject object = new LoaderObject(w, h, d);
IrisJigsawPiece piece = new IrisJigsawPiece();
IrisObject object = new IrisObject(w, h, d);
@SuppressWarnings("unchecked") ListTag<CompoundTag> blockList = (ListTag<CompoundTag>) compound.getListTag("blocks");
for (int i = 0; i < blockList.size(); i++) {
CompoundTag cp = blockList.get(i);
@@ -182,7 +182,7 @@ public class ConversionManager {
String poolId = toPoolName(pool);
String name = nbt.getString("name");
String target = nbt.getString("target");
pools.computeIfAbsent(poolId, (k) -> new LoaderJigsawPool());
pools.computeIfAbsent(poolId, (k) -> new IrisJigsawPool());
IrisJigsawPieceConnector connector = new IrisJigsawPieceConnector();
connector.setName(name);
connector.setTargetName(target);

8
src/main/java/com/volmit/iris/core/ProjectManager.java
View File

@@ -24,7 +24,7 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.project.IrisProject;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.exceptions.IrisException;
import com.volmit.iris.util.format.Form;
@@ -92,11 +92,11 @@ public class ProjectManager {
});
}
public LoaderDimension installIntoWorld(VolmitSender sender, String type, File folder) {
public IrisDimension installIntoWorld(VolmitSender sender, String type, File folder) {
sender.sendMessage("Looking for Package: " + type);
File iris = new File(folder, "iris");
File irispack = new File(folder, "iris/pack");
LoaderDimension dim = IrisData.loadAnyDimension(type);
IrisDimension dim = IrisData.loadAnyDimension(type);
if (dim == null) {
for (File i : Iris.proj.getWorkspaceFolder().listFiles()) {
@@ -262,7 +262,7 @@ public class ProjectManager {
}
String key = dim.getName().split("\\Q.\\E")[0];
LoaderDimension d = new Gson().fromJson(IO.readAll(dim), LoaderDimension.class);
IrisDimension d = new Gson().fromJson(IO.readAll(dim), IrisDimension.class);
sender.sendMessage("Importing " + d.getName() + " (" + key + ")");
File packEntry = new File(packs, key);

12
src/main/java/com/volmit/iris/core/TreeManager.java
View File

@@ -23,11 +23,11 @@ import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisToolbelt;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.common.IObjectPlacer;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.tile.TileData;
import com.volmit.iris.engine.object.trees.IrisTreeModes;
import com.volmit.iris.engine.object.trees.IrisTreeSize;
@@ -119,7 +119,7 @@ public class TreeManager implements Listener {
}
saplingPlane.forEach(block -> block.setType(Material.AIR));
LoaderObject object = worldAccess.getData().getObjectLoader().load(placement.getPlace().getRandom(RNG.r));
IrisObject object = worldAccess.getData().getObjectLoader().load(placement.getPlace().getRandom(RNG.r));
List<BlockState> blockStateList = new KList<>();
KMap<Location, BlockData> dataCache = new KMap<>();
// TODO: REAL CLASSES!!!!
@@ -232,12 +232,12 @@ public class TreeManager implements Listener {
boolean isUseAll = ((Engine) worldAccess.getEngineAccess(location.getBlockY())).getDimension().getTreeSettings().getMode().equals(IrisTreeModes.ALL);
// Retrieve objectPlacements of type `species` from biome
LoaderBiome biome = worldAccess.getBiome(location.getBlockX(), location.getBlockY(), location.getBlockZ());
IrisBiome biome = worldAccess.getBiome(location.getBlockX(), location.getBlockY(), location.getBlockZ());
placements.addAll(matchObjectPlacements(biome.getObjects(), size, type));
// Add more or find any in the region
if (isUseAll || placements.isEmpty()) {
LoaderRegion region = worldAccess.getCompound().getEngineForHeight(location.getBlockY()).getRegion(location.getBlockX(), location.getBlockZ());
IrisRegion region = worldAccess.getCompound().getEngineForHeight(location.getBlockY()).getRegion(location.getBlockX(), location.getBlockZ());
placements.addAll(matchObjectPlacements(region.getObjects(), size, type));
}

8
src/main/java/com/volmit/iris/core/WandManager.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.core;
import com.volmit.iris.Iris;
import com.volmit.iris.core.edit.DustRevealer;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.data.Cuboid;
import com.volmit.iris.util.format.C;
@@ -185,7 +185,7 @@ public class WandManager implements Listener {
}
}
public static void pasteSchematic(LoaderObject s, Location at) {
public static void pasteSchematic(IrisObject s, Location at) {
s.place(at);
}
@@ -194,7 +194,7 @@ public class WandManager implements Listener {
* @param wand The wand itemstack
* @return The new object
*/
public static LoaderObject createSchematic(ItemStack wand) {
public static IrisObject createSchematic(ItemStack wand) {
if (!isWand(wand)) {
return null;
}
@@ -202,7 +202,7 @@ public class WandManager implements Listener {
try {
Location[] f = getCuboid(wand);
Cuboid c = new Cuboid(f[0], f[1]);
LoaderObject s = new LoaderObject(c.getSizeX(), c.getSizeY(), c.getSizeZ());
IrisObject s = new IrisObject(c.getSizeX(), c.getSizeY(), c.getSizeZ());
for (Block b : c) {
if (b.getType().equals(Material.AIR)) {
continue;

4
src/main/java/com/volmit/iris/core/command/jigsaw/CommandIrisJigsawEdit.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.edit.JigsawEditor;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -59,7 +59,7 @@ public class CommandIrisJigsawEdit extends MortarCommand {
return true;
}
LoaderJigsawPiece piece = IrisData.loadAnyJigsawPiece(args[0]);
IrisJigsawPiece piece = IrisData.loadAnyJigsawPiece(args[0]);
if (piece != null) {
File dest = piece.getLoadFile();

4
src/main/java/com/volmit/iris/core/command/jigsaw/CommandIrisJigsawNew.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.edit.JigsawEditor;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -59,7 +59,7 @@ public class CommandIrisJigsawNew extends MortarCommand {
return true;
}
LoaderObject object = IrisData.loadAnyObject(args[2]);
IrisObject object = IrisData.loadAnyObject(args[2]);
if (object == null) {
sender.sendMessage("Failed to find existing object: " + args[2]);

4
src/main/java/com/volmit/iris/core/command/jigsaw/CommandIrisJigsawPlace.java
View File

@@ -23,7 +23,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.jigsaw.PlannedStructure;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.format.Form;
@@ -71,7 +71,7 @@ public class CommandIrisJigsawPlace extends MortarCommand {
return true;
}
LoaderJigsawStructure str = IrisData.loadAnyJigsawStructure(args[0]);
IrisJigsawStructure str = IrisData.loadAnyJigsawStructure(args[0]);
if (str != null) {
PrecisionStopwatch p = PrecisionStopwatch.start();

4
src/main/java/com/volmit/iris/core/command/object/CommandIrisObjectAnalyze.java
View File

@@ -5,7 +5,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.ProjectManager;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -75,7 +75,7 @@ public class CommandIrisObjectAnalyze extends MortarCommand {
Player p = sender.player();
J.a(() -> {
LoaderObject obj = IrisData.loadAnyObject(args[0]);
IrisObject obj = IrisData.loadAnyObject(args[0]);
if (obj == null || obj.getLoadFile() == null) {
sender.sendMessage("Can't find " + args[0] + " in the " + ProjectManager.WORKSPACE_NAME + " folder");

4
src/main/java/com/volmit/iris/core/command/object/CommandIrisObjectPaste.java
View File

@@ -24,7 +24,7 @@ import com.volmit.iris.core.ProjectManager;
import com.volmit.iris.core.WandManager;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.objects.IrisObjectPlacementScaleInterpolator;
import com.volmit.iris.engine.object.objects.IrisObjectRotation;
@@ -91,7 +91,7 @@ public class CommandIrisObjectPaste extends MortarCommand {
}
Player p = sender.player();
LoaderObject obj = IrisData.loadAnyObject(args[0]);
IrisObject obj = IrisData.loadAnyObject(args[0]);
if (obj == null || obj.getLoadFile() == null) {

4
src/main/java/com/volmit/iris/core/command/object/CommandIrisObjectSave.java
View File

@@ -21,7 +21,7 @@ package com.volmit.iris.core.command.object;
import com.volmit.iris.Iris;
import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.WandManager;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -75,7 +75,7 @@ public class CommandIrisObjectSave extends MortarCommand {
Player p = sender.player();
ItemStack wand = p.getInventory().getItemInMainHand();
LoaderObject o = WandManager.createSchematic(wand);
IrisObject o = WandManager.createSchematic(wand);
File file = Iris.proj.getWorkspaceFile(args[0], "objects", args[1] + ".iob");
if (file.exists()) {

4
src/main/java/com/volmit/iris/core/command/studio/CommandIrisStudioExplorerGenerator.java
View File

@@ -23,7 +23,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.gui.NoiseExplorerGUI;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.function.Function2;
import com.volmit.iris.util.math.RNG;
@@ -74,7 +74,7 @@ public class CommandIrisStudioExplorerGenerator extends MortarCommand {
Supplier<Function2<Double, Double, Double>> l = () -> {
long seed = 12345;
LoaderGenerator generator;
IrisGenerator generator;
if (Iris.proj.isProjectOpen()) {
generator = Iris.proj.getActiveProject().getActiveProvider().getData().getGeneratorLoader().load(args[0]);
seed = Iris.proj.getActiveProject().getActiveProvider().getTarget().getWorld().seed();

12
src/main/java/com/volmit/iris/core/command/studio/CommandIrisStudioGoto.java
View File

@@ -22,9 +22,9 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.format.C;
import com.volmit.iris.util.format.Form;
@@ -81,9 +81,9 @@ public class CommandIrisStudioGoto extends MortarCommand {
}
IrisAccess g = IrisWorlds.access(world);
LoaderBiome b = IrisData.loadAnyBiome(args[0]);
LoaderRegion r = IrisData.loadAnyRegion(args[0]);
LoaderJigsawStructure s = IrisData.loadAnyJigsawStructure(args[0]);
IrisBiome b = IrisData.loadAnyBiome(args[0]);
IrisRegion r = IrisData.loadAnyRegion(args[0]);
IrisJigsawStructure s = IrisData.loadAnyJigsawStructure(args[0]);
if (b != null) {
J.a(() -> {

6
src/main/java/com/volmit/iris/core/command/studio/CommandIrisStudioLoot.java
View File

@@ -23,7 +23,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.meta.InventorySlotType;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.math.RNG;
import com.volmit.iris.util.plugin.MortarCommand;
@@ -63,7 +63,7 @@ public class CommandIrisStudioLoot extends MortarCommand {
return true;
}
KList<LoaderLootTable> tables = prov.getCompound().getEngine(p.getLocation().getBlockY()).getLootTables(RNG.r, p.getLocation().getBlock());
KList<IrisLootTable> tables = prov.getCompound().getEngine(p.getLocation().getBlockY()).getLootTables(RNG.r, p.getLocation().getBlock());
Inventory inv = Bukkit.createInventory(null, 27 * 2);
try {
@@ -76,7 +76,7 @@ public class CommandIrisStudioLoot extends MortarCommand {
p.openInventory(inv);
for (LoaderLootTable i : tables) {
for (IrisLootTable i : tables) {
sender.sendMessage("- " + i.getName());
}

12
src/main/java/com/volmit/iris/core/command/studio/CommandIrisStudioProfile.java
View File

@@ -23,13 +23,13 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.project.IrisProject;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.util.interpolation.InterpolationMethod;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomePaletteLayer;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import com.volmit.iris.engine.object.noise.IrisInterpolator;
import com.volmit.iris.engine.object.noise.IrisNoiseGenerator;
import com.volmit.iris.engine.object.noise.NoiseStyle;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.noise.CNG;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
@@ -158,7 +158,7 @@ public class CommandIrisStudioProfile extends MortarCommand {
for (String i : data.getGeneratorLoader().getPossibleKeys()) {
KList<String> vv = new KList<>();
LoaderGenerator g = data.getGeneratorLoader().load(i);
IrisGenerator g = data.getGeneratorLoader().load(i);
KList<IrisNoiseGenerator> composites = g.getAllComposites();
double score = 0;
int m = 0;
@@ -188,7 +188,7 @@ public class CommandIrisStudioProfile extends MortarCommand {
for (String i : data.getBiomeLoader().getPossibleKeys()) {
KList<String> vv = new KList<>();
LoaderBiome b = data.getBiomeLoader().load(i);
IrisBiome b = data.getBiomeLoader().load(i);
double score = 0;
int m = 0;
@@ -217,7 +217,7 @@ public class CommandIrisStudioProfile extends MortarCommand {
v.add("");
for (String i : data.getRegionLoader().getPossibleKeys()) {
LoaderRegion b = data.getRegionLoader().load(i);
IrisRegion b = data.getRegionLoader().load(i);
double score = 0;
score += styleTimings.get(b.getLakeStyle().getStyle());

4
src/main/java/com/volmit/iris/core/command/studio/CommandIrisStudioSummon.java
View File

@@ -23,7 +23,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.entity.LoaderEntity;
import com.volmit.iris.engine.object.entity.IrisEntity;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -65,7 +65,7 @@ public class CommandIrisStudioSummon extends MortarCommand {
sender.sendMessage("- " + i);
}
} else {
LoaderEntity e = g.getData().getEntityLoader().load(args[0]);
IrisEntity e = g.getData().getEntityLoader().load(args[0]);
if (e == null) {
sender.sendMessage("Couldnt find entity " + args[0] + ". Use '/iris std summon' to see a list of iris entities.");

4
src/main/java/com/volmit/iris/core/command/what/CommandIrisWhatBiome.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.nms.INMS;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.plugin.MortarCommand;
import com.volmit.iris.util.plugin.VolmitSender;
@@ -54,7 +54,7 @@ public class CommandIrisWhatBiome extends MortarCommand {
IrisAccess g = IrisWorlds.access(w);
assert g != null;
LoaderBiome b = g.getBiome(p.getLocation().getBlockX(), p.getLocation().getBlockY(), p.getLocation().getBlockZ());
IrisBiome b = g.getBiome(p.getLocation().getBlockX(), p.getLocation().getBlockY(), p.getLocation().getBlockZ());
sender.sendMessage("IBiome: " + b.getLoadKey() + " (" + b.getDerivative().name() + ")");
} catch (Throwable e) {

2
src/main/java/com/volmit/iris/core/command/what/CommandIrisWhatBlock.java
View File

@@ -19,7 +19,7 @@
package com.volmit.iris.core.command.what;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.format.C;
import com.volmit.iris.util.plugin.MortarCommand;

12
src/main/java/com/volmit/iris/core/command/what/CommandIrisWhatObjects.java
View File

@@ -21,8 +21,8 @@ package com.volmit.iris.core.command.what;
import com.volmit.iris.Iris;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
@@ -139,8 +139,8 @@ public class CommandIrisWhatObjects extends MortarCommand {
for (int k = 0; k < 16; k += 3) {
assert g != null;
LoaderBiome bb = g.getBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
LoaderBiome bxf = g.getCaveBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
IrisBiome bb = g.getBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
IrisBiome bxf = g.getCaveBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
biomes.addIfMissing(bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")");
caveBiomes.addIfMissing(bxf.getName() + " (" + bxf.getLoadFile().getName() + ")");
exportObjects(bb, pw, g, objects);
@@ -199,7 +199,7 @@ public class CommandIrisWhatObjects extends MortarCommand {
return true;
}
private void exportObjects(LoaderBiome bb, PrintWriter pw, IrisAccess g, KMap<String, KMap<String, KList<String>>> objects) {
private void exportObjects(IrisBiome bb, PrintWriter pw, IrisAccess g, KMap<String, KMap<String, KList<String>>> objects) {
String n1 = bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")";
int m = 0;
KSet<String> stop = new KSet<>();
@@ -216,7 +216,7 @@ public class CommandIrisWhatObjects extends MortarCommand {
}
File ff = g.getData().getObjectLoader().findFile(i);
BlockVector sz = LoaderObject.sampleSize(ff);
BlockVector sz = IrisObject.sampleSize(ff);
nn3 = i + ": size=[" + sz.getBlockX() + "," + sz.getBlockY() + "," + sz.getBlockZ() + "] location=[" + ff.getPath() + "]";
stop.add(i);
} catch (Throwable e) {

4
src/main/java/com/volmit/iris/core/command/world/CommandIrisCreate.java
View File

@@ -25,7 +25,7 @@ import com.volmit.iris.core.nms.INMS;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorldCreator;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.format.Form;
import com.volmit.iris.util.plugin.MortarCommand;
@@ -139,7 +139,7 @@ public class CommandIrisCreate extends MortarCommand {
Iris.linkMultiverseCore.assignWorldType(worldName, type);
final AtomicReference<World> world = new AtomicReference<>();
LoaderDimension dim;
IrisDimension dim;
File folder = new File(worldName);
Runnable onDone = () -> {

6
src/main/java/com/volmit/iris/core/command/world/CommandIrisVerify.java
View File

@@ -20,9 +20,9 @@ package com.volmit.iris.core.command.world;
import com.volmit.iris.Iris;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.data.mca.Chunk;
import com.volmit.iris.engine.data.mca.MCAFile;
import com.volmit.iris.engine.data.mca.MCAUtil;
import com.volmit.iris.util.nbt.mca.Chunk;
import com.volmit.iris.util.nbt.mca.MCAFile;
import com.volmit.iris.util.nbt.mca.MCAUtil;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.util.parallel.BurstExecutor;
import com.volmit.iris.util.parallel.MultiBurst;

12
src/main/java/com/volmit/iris/core/edit/JigsawEditor.java
View File

@@ -21,10 +21,10 @@ package com.volmit.iris.core.edit;
import com.google.gson.Gson;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPieceConnector;
import com.volmit.iris.engine.object.objects.IrisDirection;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.data.Cuboid;
import com.volmit.iris.util.io.IO;
@@ -50,9 +50,9 @@ import java.io.IOException;
public class JigsawEditor implements Listener {
public static final KMap<Player, JigsawEditor> editors = new KMap<>();
private final Player player;
private final LoaderObject object;
private final IrisObject object;
private final File targetSaveLocation;
private final LoaderJigsawPiece piece;
private final IrisJigsawPiece piece;
private final Location origin;
private final Cuboid cuboid;
private final int ticker;
@@ -60,7 +60,7 @@ public class JigsawEditor implements Listener {
private final KMap<IrisPosition, Runnable> falling = new KMap<>();
private final ChronoLatch cl = new ChronoLatch(100);
public JigsawEditor(Player player, LoaderJigsawPiece piece, LoaderObject object, File saveLocation) {
public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
if (editors.containsKey(player)) {
editors.get(player).close();
}
@@ -71,7 +71,7 @@ public class JigsawEditor implements Listener {
origin = player.getLocation().clone().add(0, 7, 0);
target = origin;
this.targetSaveLocation = saveLocation;
this.piece = piece == null ? new LoaderJigsawPiece() : piece;
this.piece = piece == null ? new IrisJigsawPiece() : piece;
this.piece.setObject(object.getLoadKey());
cuboid = new Cuboid(origin.clone(), origin.clone().add(object.getW() - 1, object.getH() - 1, object.getD() - 1));
ticker = J.sr(this::onTick, 0);

8
src/main/java/com/volmit/iris/core/gui/VisionGUI.java
View File

@@ -25,8 +25,8 @@ import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.IrisComplex;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
@@ -629,8 +629,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
}
private void renderHoverOverlay(Graphics2D g, boolean detailed) {
LoaderBiome biome = engine.getFramework().getComplex().getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz));
LoaderRegion region = engine.getFramework().getComplex().getRegionStream().get(getWorldX(hx), getWorldZ(hz));
IrisBiome biome = engine.getFramework().getComplex().getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz));
IrisRegion region = engine.getFramework().getComplex().getRegionStream().get(getWorldX(hx), getWorldZ(hz));
KList<String> l = new KList<>();
l.add("Biome: " + biome.getName());
l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");

4
src/main/java/com/volmit/iris/core/link/MultiverseCoreLink.java
View File

@@ -19,7 +19,7 @@
package com.volmit.iris.core.link;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.collection.KMap;
import org.bukkit.Bukkit;
import org.bukkit.World;
@@ -37,7 +37,7 @@ public class MultiverseCoreLink {
}
public boolean addWorld(String worldName, LoaderDimension dim, String seed) {
public boolean addWorld(String worldName, IrisDimension dim, String seed) {
if (!supported()) {
return false;
}

2
src/main/java/com/volmit/iris/core/link/OraxenLink.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.core.link;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import org.bukkit.Bukkit;
import org.bukkit.block.data.BlockData;
import org.bukkit.inventory.ItemStack;

6
src/main/java/com/volmit/iris/core/pregenerator/methods/SyndicatePregenMethod.java
View File

@@ -25,7 +25,7 @@ import com.volmit.iris.core.pregenerator.PregenTask;
import com.volmit.iris.core.pregenerator.PregeneratorMethod;
import com.volmit.iris.core.pregenerator.syndicate.SyndicateClient;
import com.volmit.iris.core.pregenerator.syndicate.command.*;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.io.IO;
import com.volmit.iris.util.scheduling.J;
import lombok.Getter;
@@ -42,13 +42,13 @@ public class SyndicatePregenMethod implements PregeneratorMethod {
private String nickname;
private final int port;
private final String password;
private final LoaderDimension dimension;
private final IrisDimension dimension;
private boolean ready = false;
private final File worldFolder;
private final UUID pack = UUID.randomUUID();
private final long seed;
public SyndicatePregenMethod(String nickname, File worldFolder, String address, int port, String password, LoaderDimension dimension, long seed) {
public SyndicatePregenMethod(String nickname, File worldFolder, String address, int port, String password, IrisDimension dimension, long seed) {
this.seed = seed;
this.worldFolder = worldFolder;
this.address = address;

4
src/main/java/com/volmit/iris/core/pregenerator/syndicate/command/SyndicateInstallPack.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.core.pregenerator.syndicate.command;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
@@ -38,5 +38,5 @@ public class SyndicateInstallPack implements SyndicateCommand {
private long seed = 1337;
@Builder.Default
private LoaderDimension dimension = null;
private IrisDimension dimension = null;
}

66
src/main/java/com/volmit/iris/core/project/IrisProject.java
View File

@@ -29,17 +29,17 @@ import com.volmit.iris.core.report.ReportType;
import com.volmit.iris.core.tools.IrisWorldCreator;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomeMutation;
import com.volmit.iris.engine.object.biome.IrisBiomePaletteLayer;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.entity.LoaderEntity;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.entity.IrisEntity;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.util.parallel.MultiBurst;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
@@ -103,7 +103,7 @@ public class IrisProject {
if (activeProvider != null && activeProvider.getCompound() != null) {
for (int i = 0; i < getActiveProvider().getCompound().getSize(); i++) {
Engine e = getActiveProvider().getCompound().getEngine(i);
LoaderDimension dim = e.getDimension();
IrisDimension dim = e.getDimension();
reports.add(scanForErrors(dim));
}
}
@@ -120,7 +120,7 @@ public class IrisProject {
return reports;
}
private KList<Report> scanForErrors(LoaderDimension dim) {
private KList<Report> scanForErrors(IrisDimension dim) {
KList<Report> reports = new KList<>();
if (dim.getFocus() != null && !dim.getFocus().isEmpty()) {
@@ -132,14 +132,14 @@ public class IrisProject {
.build());
}
for (LoaderRegion i : dim.getAllRegions(getActiveProvider())) {
for (IrisRegion i : dim.getAllRegions(getActiveProvider())) {
scanForErrors(i);
}
return reports;
}
private KList<Report> scanForErrors(LoaderRegion region) {
private KList<Report> scanForErrors(IrisRegion region) {
KList<Report> reports = new KList<>();
if (region.getRarity() > 60) {
@@ -151,14 +151,14 @@ public class IrisProject {
.build());
}
for (LoaderBiome i : region.getAllBiomes(getActiveProvider())) {
for (IrisBiome i : region.getAllBiomes(getActiveProvider())) {
reports.add(scanForErrors(i));
}
return reports;
}
private KList<Report> scanForErrors(LoaderBiome biome) {
private KList<Report> scanForErrors(IrisBiome biome) {
KList<Report> reports = new KList<>();
for (IrisObjectPlacement i : biome.getObjects()) {
@@ -176,17 +176,17 @@ public class IrisProject {
return reports;
}
private KList<Report> scanForErrors(LoaderBiome biome, IrisObjectPlacement i) {
private KList<Report> scanForErrors(IrisBiome biome, IrisObjectPlacement i) {
return new KList<>();
}
private KList<Report> scanForErrors(LoaderBiome biome, IrisBiomePaletteLayer i) {
private KList<Report> scanForErrors(IrisBiome biome, IrisBiomePaletteLayer i) {
return new KList<>();
}
private KList<Report> scanForErrorsSeaLayers(LoaderBiome biome, IrisBiomePaletteLayer i) {
private KList<Report> scanForErrorsSeaLayers(IrisBiome biome, IrisBiomePaletteLayer i) {
return new KList<>();
}
@@ -255,7 +255,7 @@ public class IrisProject {
return;
}
LoaderDimension d = IrisData.loadAnyDimension(getName());
IrisDimension d = IrisData.loadAnyDimension(getName());
if (d == null) {
sender.sendMessage("Can't find dimension: " + getName());
return;
@@ -467,17 +467,17 @@ public class IrisProject {
public File compilePackage(VolmitSender sender, boolean obfuscate, boolean minify) {
String dimm = getName();
IrisData dm = new IrisData(path);
LoaderDimension dimension = dm.getDimensionLoader().load(dimm);
IrisDimension dimension = dm.getDimensionLoader().load(dimm);
File folder = new File(Iris.instance.getDataFolder(), "exports/" + dimension.getLoadKey());
folder.mkdirs();
Iris.info("Packaging Dimension " + dimension.getName() + " " + (obfuscate ? "(Obfuscated)" : ""));
KSet<LoaderRegion> regions = new KSet<>();
KSet<LoaderBiome> biomes = new KSet<>();
KSet<LoaderEntity> entities = new KSet<>();
KSet<LoaderSpawner> spawners = new KSet<>();
KSet<LoaderGenerator> generators = new KSet<>();
KSet<LoaderLootTable> loot = new KSet<>();
KSet<LoaderBlockData> blocks = new KSet<>();
KSet<IrisRegion> regions = new KSet<>();
KSet<IrisBiome> biomes = new KSet<>();
KSet<IrisEntity> entities = new KSet<>();
KSet<IrisSpawner> spawners = new KSet<>();
KSet<IrisGenerator> generators = new KSet<>();
KSet<IrisLootTable> loot = new KSet<>();
KSet<IrisBlockData> blocks = new KSet<>();
for (String i : dm.getDimensionLoader().getPossibleKeys()) {
blocks.add(dm.getBlockLoader().load(i));
@@ -528,7 +528,7 @@ public class IrisProject {
StringBuilder c = new StringBuilder();
sender.sendMessage("Serializing Objects");
for (LoaderBiome i : biomes) {
for (IrisBiome i : biomes) {
for (IrisObjectPlacement j : i.getObjects()) {
b.append(j.hashCode());
KList<String> newNames = new KList<>();
@@ -622,7 +622,7 @@ public class IrisProject {
IO.writeAll(new File(folder, "dimensions/" + dimension.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
for (LoaderGenerator i : generators) {
for (IrisGenerator i : generators) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "generators/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
@@ -631,31 +631,31 @@ public class IrisProject {
c.append(IO.hash(b.toString()));
b = new StringBuilder();
for (LoaderRegion i : regions) {
for (IrisRegion i : regions) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "regions/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
}
for (LoaderBlockData i : blocks) {
for (IrisBlockData i : blocks) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "blocks/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
}
for (LoaderBiome i : biomes) {
for (IrisBiome i : biomes) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "biomes/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
}
for (LoaderEntity i : entities) {
for (IrisEntity i : entities) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "entities/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));
}
for (LoaderLootTable i : loot) {
for (IrisLootTable i : loot) {
a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
IO.writeAll(new File(folder, "loot/" + i.getLoadKey() + ".json"), a);
b.append(IO.hash(a));

2
src/main/java/com/volmit/iris/core/project/SchemaBuilder.java
View File

@@ -21,7 +21,7 @@ package com.volmit.iris.core.project;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.project.loader.ResourceLoader;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;

122
src/main/java/com/volmit/iris/core/project/loader/IrisData.java
View File

@@ -20,20 +20,20 @@ package com.volmit.iris.core.project.loader;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.entity.LoaderEntity;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPool;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.mods.LoaderMod;
import com.volmit.iris.engine.object.noise.LoaderExpression;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.entity.IrisEntity;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPool;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.engine.object.mods.IrisMod;
import com.volmit.iris.engine.object.noise.IrisExpression;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.math.RNG;
import lombok.Data;
@@ -44,21 +44,21 @@ import java.util.function.Function;
@Data
public class IrisData {
private ResourceLoader<LoaderBiome> biomeLoader;
private ResourceLoader<LoaderLootTable> lootLoader;
private ResourceLoader<LoaderRegion> regionLoader;
private ResourceLoader<LoaderDimension> dimensionLoader;
private ResourceLoader<LoaderGenerator> generatorLoader;
private ResourceLoader<LoaderJigsawPiece> jigsawPieceLoader;
private ResourceLoader<LoaderJigsawPool> jigsawPoolLoader;
private ResourceLoader<LoaderJigsawStructure> jigsawStructureLoader;
private ResourceLoader<LoaderEntity> entityLoader;
private ResourceLoader<LoaderSpawner> spawnerLoader;
private ResourceLoader<LoaderMod> modLoader;
private ResourceLoader<LoaderBlockData> blockLoader;
private ResourceLoader<LoaderExpression> expressionLoader;
private ResourceLoader<LoaderObject> objectLoader;
private KMap<Class<? extends LoaderRegistrant>, ResourceLoader<? extends LoaderRegistrant>> loaders = new KMap<>();
private ResourceLoader<IrisBiome> biomeLoader;
private ResourceLoader<IrisLootTable> lootLoader;
private ResourceLoader<IrisRegion> regionLoader;
private ResourceLoader<IrisDimension> dimensionLoader;
private ResourceLoader<IrisGenerator> generatorLoader;
private ResourceLoader<IrisJigsawPiece> jigsawPieceLoader;
private ResourceLoader<IrisJigsawPool> jigsawPoolLoader;
private ResourceLoader<IrisJigsawStructure> jigsawStructureLoader;
private ResourceLoader<IrisEntity> entityLoader;
private ResourceLoader<IrisSpawner> spawnerLoader;
private ResourceLoader<IrisMod> modLoader;
private ResourceLoader<IrisBlockData> blockLoader;
private ResourceLoader<IrisExpression> expressionLoader;
private ResourceLoader<IrisObject> objectLoader;
private KMap<Class<? extends IrisRegistrant>, ResourceLoader<? extends IrisRegistrant>> loaders = new KMap<>();
private boolean closed;
private final File dataFolder;
private Engine engine;
@@ -90,11 +90,11 @@ public class IrisData {
return new IrisData(dataFolder);
}
private <T extends LoaderRegistrant> ResourceLoader<T> registerLoader(Class<T> registrant) {
private <T extends IrisRegistrant> ResourceLoader<T> registerLoader(Class<T> registrant) {
try {
LoaderRegistrant rr = registrant.getConstructor().newInstance();
IrisRegistrant rr = registrant.getConstructor().newInstance();
ResourceLoader<T> r = null;
if (registrant.equals(LoaderObject.class)) {
if (registrant.equals(IrisObject.class)) {
r = (ResourceLoader<T>) new ObjectResourceLoader(dataFolder, this, rr.getFolderName(), rr.getTypeName());
} else {
r = new ResourceLoader<T>(dataFolder, this, rr.getFolderName(), rr.getTypeName(), registrant);
@@ -119,20 +119,20 @@ public class IrisData {
loaders.clear();
File packs = dataFolder;
packs.mkdirs();
this.lootLoader = registerLoader(LoaderLootTable.class);
this.spawnerLoader = registerLoader(LoaderSpawner.class);
this.entityLoader = registerLoader(LoaderEntity.class);
this.regionLoader = registerLoader(LoaderRegion.class);
this.biomeLoader = registerLoader(LoaderBiome.class);
this.modLoader = registerLoader(LoaderMod.class);
this.dimensionLoader = registerLoader(LoaderDimension.class);
this.jigsawPoolLoader = registerLoader(LoaderJigsawPool.class);
this.jigsawStructureLoader = registerLoader(LoaderJigsawStructure.class);
this.jigsawPieceLoader = registerLoader(LoaderJigsawPiece.class);
this.generatorLoader = registerLoader(LoaderGenerator.class);
this.blockLoader = registerLoader(LoaderBlockData.class);
this.expressionLoader = registerLoader(LoaderExpression.class);
this.objectLoader = registerLoader(LoaderObject.class);
this.lootLoader = registerLoader(IrisLootTable.class);
this.spawnerLoader = registerLoader(IrisSpawner.class);
this.entityLoader = registerLoader(IrisEntity.class);
this.regionLoader = registerLoader(IrisRegion.class);
this.biomeLoader = registerLoader(IrisBiome.class);
this.modLoader = registerLoader(IrisMod.class);
this.dimensionLoader = registerLoader(IrisDimension.class);
this.jigsawPoolLoader = registerLoader(IrisJigsawPool.class);
this.jigsawStructureLoader = registerLoader(IrisJigsawStructure.class);
this.jigsawPieceLoader = registerLoader(IrisJigsawPiece.class);
this.generatorLoader = registerLoader(IrisGenerator.class);
this.blockLoader = registerLoader(IrisBlockData.class);
this.expressionLoader = registerLoader(IrisExpression.class);
this.objectLoader = registerLoader(IrisObject.class);
}
public void dump() {
@@ -155,63 +155,63 @@ public class IrisData {
}
}
public static LoaderObject loadAnyObject(String key) {
public static IrisObject loadAnyObject(String key) {
return loadAny(key, (dm) -> dm.getObjectLoader().load(key, false));
}
public static LoaderBiome loadAnyBiome(String key) {
public static IrisBiome loadAnyBiome(String key) {
return loadAny(key, (dm) -> dm.getBiomeLoader().load(key, false));
}
public static LoaderExpression loadAnyExpression(String key) {
public static IrisExpression loadAnyExpression(String key) {
return loadAny(key, (dm) -> dm.getExpressionLoader().load(key, false));
}
public static LoaderMod loadAnyMod(String key) {
public static IrisMod loadAnyMod(String key) {
return loadAny(key, (dm) -> dm.getModLoader().load(key, false));
}
public static LoaderJigsawPiece loadAnyJigsawPiece(String key) {
public static IrisJigsawPiece loadAnyJigsawPiece(String key) {
return loadAny(key, (dm) -> dm.getJigsawPieceLoader().load(key, false));
}
public static LoaderJigsawPool loadAnyJigsawPool(String key) {
public static IrisJigsawPool loadAnyJigsawPool(String key) {
return loadAny(key, (dm) -> dm.getJigsawPoolLoader().load(key, false));
}
public static LoaderEntity loadAnyEntity(String key) {
public static IrisEntity loadAnyEntity(String key) {
return loadAny(key, (dm) -> dm.getEntityLoader().load(key, false));
}
public static LoaderLootTable loadAnyLootTable(String key) {
public static IrisLootTable loadAnyLootTable(String key) {
return loadAny(key, (dm) -> dm.getLootLoader().load(key, false));
}
public static LoaderBlockData loadAnyBlock(String key) {
public static IrisBlockData loadAnyBlock(String key) {
return loadAny(key, (dm) -> dm.getBlockLoader().load(key, false));
}
public static LoaderSpawner loadAnySpaner(String key) {
public static IrisSpawner loadAnySpaner(String key) {
return loadAny(key, (dm) -> dm.getSpawnerLoader().load(key, false));
}
public static LoaderRegion loadAnyRegion(String key) {
public static IrisRegion loadAnyRegion(String key) {
return loadAny(key, (dm) -> dm.getRegionLoader().load(key, false));
}
public static LoaderDimension loadAnyDimension(String key) {
public static IrisDimension loadAnyDimension(String key) {
return loadAny(key, (dm) -> dm.getDimensionLoader().load(key, false));
}
public static LoaderJigsawStructure loadAnyJigsawStructure(String key) {
public static IrisJigsawStructure loadAnyJigsawStructure(String key) {
return loadAny(key, (dm) -> dm.getJigsawStructureLoader().load(key, false));
}
public static LoaderGenerator loadAnyGenerator(String key) {
public static IrisGenerator loadAnyGenerator(String key) {
return loadAny(key, (dm) -> dm.getGeneratorLoader().load(key, false));
}
public static <T extends LoaderRegistrant> T loadAny(String key, Function<IrisData, T> v) {
public static <T extends IrisRegistrant> T loadAny(String key, Function<IrisData, T> v) {
try {
for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
if (i.isDirectory()) {

2
src/main/java/com/volmit/iris/core/project/loader/LoaderRegistrant.java → src/main/java/com/volmit/iris/core/project/loader/IrisRegistrant.java
View File

@@ -26,7 +26,7 @@ import java.awt.*;
import java.io.File;
@Data
public abstract class LoaderRegistrant {
public abstract class IrisRegistrant {
private transient IrisData loader;
private transient String loadKey;

18
src/main/java/com/volmit/iris/core/project/loader/ObjectResourceLoader.java
View File

@@ -19,7 +19,7 @@
package com.volmit.iris.core.project.loader;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.collection.KSet;
@@ -33,14 +33,14 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
import java.io.File;
import java.util.concurrent.atomic.AtomicInteger;
public class ObjectResourceLoader extends ResourceLoader<LoaderObject> {
public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
private final ChronoLatch useFlip = new ChronoLatch(2222);
private final KMap<String, Long> useCache = new KMap<>();
private final ChronoLatch cl;
private final AtomicInteger unload;
public ObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
super(root, idm, folderName, resourceTypeName, LoaderObject.class);
super(root, idm, folderName, resourceTypeName, IrisObject.class);
cl = new ChronoLatch(30000);
unload = new AtomicInteger(0);
}
@@ -56,7 +56,7 @@ public class ObjectResourceLoader extends ResourceLoader<LoaderObject> {
public int getTotalStorage() {
int m = 0;
for (LoaderObject i : loadCache.values()) {
for (IrisObject i : loadCache.values()) {
m += i.getBlocks().size();
}
@@ -115,11 +115,11 @@ public class ObjectResourceLoader extends ResourceLoader<LoaderObject> {
}
}
public LoaderObject loadFile(File j, String key, String name) {
public IrisObject loadFile(File j, String key, String name) {
lock.lock();
try {
PrecisionStopwatch p = PrecisionStopwatch.start();
LoaderObject t = new LoaderObject(0, 0, 0);
IrisObject t = new IrisObject(0, 0, 0);
t.read(j);
loadCache.put(key, t);
t.setLoadKey(name);
@@ -194,15 +194,15 @@ public class ObjectResourceLoader extends ResourceLoader<LoaderObject> {
return null;
}
public LoaderObject load(String name) {
public IrisObject load(String name) {
return load(name, true);
}
public LoaderObject load(String name, boolean warn) {
public IrisObject load(String name, boolean warn) {
String key = name + "-" + objectClass.getCanonicalName();
if (loadCache.containsKey(key)) {
LoaderObject t = loadCache.get(key);
IrisObject t = loadCache.get(key);
useCache.put(key, M.ms());
return t;
}

2
src/main/java/com/volmit/iris/core/project/loader/ResourceLoader.java
View File

@@ -43,7 +43,7 @@ import java.util.function.Predicate;
import java.util.stream.Stream;
@Data
public class ResourceLoader<T extends LoaderRegistrant> {
public class ResourceLoader<T extends IrisRegistrant> {
public static final AtomicDouble tlt = new AtomicDouble(0);
protected File root;
protected String folderName;

4
src/main/java/com/volmit/iris/core/tools/IrisCreator.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.pregenerator.PregenTask;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.framework.headless.HeadlessWorld;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.exceptions.IrisException;
import com.volmit.iris.util.exceptions.MissingDimensionException;
import com.volmit.iris.util.format.C;
@@ -93,7 +93,7 @@ public class IrisCreator {
* @throws IrisException shit happens
*/
public IrisAccess create() throws IrisException {
LoaderDimension d = IrisToolbelt.getDimension(dimension());
IrisDimension d = IrisToolbelt.getDimension(dimension());
IrisAccess access = null;
Consumer<Double> prog = (pxx) -> {
double px = pxx;

4
src/main/java/com/volmit/iris/core/tools/IrisToolbelt.java
View File

@@ -27,7 +27,7 @@ import com.volmit.iris.core.pregenerator.methods.HeadlessPregenMethod;
import com.volmit.iris.core.pregenerator.methods.HybridPregenMethod;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.util.plugin.VolmitSender;
import org.bukkit.Bukkit;
import org.bukkit.World;
@@ -50,7 +50,7 @@ public class IrisToolbelt {
* @param dimension the dimension id such as overworld or flat
* @return the IrisDimension or null
*/
public static LoaderDimension getDimension(String dimension) {
public static IrisDimension getDimension(String dimension) {
File pack = Iris.instance.getDataFolder("packs", dimension);
if (!pack.exists()) {

4
src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.core.tools;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.framework.EngineCompositeGenerator;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.common.IrisWorld;
import org.bukkit.World;
import org.bukkit.WorldCreator;
@@ -93,7 +93,7 @@ public class IrisWorldCreator {
}
private World.Environment findEnvironment() {
LoaderDimension dim = IrisData.loadAnyDimension(dimensionName);
IrisDimension dim = IrisData.loadAnyDimension(dimensionName);
if (dim == null || dim.getEnvironment() == null) {
return World.Environment.NORMAL;
} else {

76
src/main/java/com/volmit/iris/engine/IrisComplex.java
View File

@@ -22,18 +22,18 @@ import com.google.common.util.concurrent.AtomicDouble;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.actuator.IrisTerrainNormalActuator;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.modifier.IrisCaveModifier;
import com.volmit.iris.engine.object.biome.InferredType;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.engine.object.dimensional.IrisTerrainMode;
import com.volmit.iris.engine.object.feature.IrisFeaturePositional;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import com.volmit.iris.engine.object.noise.IrisInterpolator;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.noise.CNG;
import com.volmit.iris.engine.object.common.CaveResult;
import com.volmit.iris.util.stream.ProceduralStream;
@@ -55,9 +55,9 @@ public class IrisComplex implements DataProvider {
private RNG rng;
private double fluidHeight;
private IrisData data;
private KList<LoaderGenerator> generators;
private KList<IrisGenerator> generators;
private static final BlockData AIR = Material.AIR.createBlockData();
private ProceduralStream<LoaderRegion> regionStream;
private ProceduralStream<IrisRegion> regionStream;
private ProceduralStream<Double> regionStyleStream;
private ProceduralStream<Double> regionIdentityStream;
private ProceduralStream<UUID> regionIDStream;
@@ -65,14 +65,14 @@ public class IrisComplex implements DataProvider {
private ProceduralStream<Double> islandHeightStream;
private ProceduralStream<Double> islandDepthStream;
private ProceduralStream<InferredType> bridgeStream;
private ProceduralStream<LoaderBiome> landBiomeStream;
private ProceduralStream<LoaderBiome> caveBiomeStream;
private ProceduralStream<LoaderBiome> seaBiomeStream;
private ProceduralStream<LoaderBiome> shoreBiomeStream;
private ProceduralStream<LoaderBiome> baseBiomeStream;
private ProceduralStream<IrisBiome> landBiomeStream;
private ProceduralStream<IrisBiome> caveBiomeStream;
private ProceduralStream<IrisBiome> seaBiomeStream;
private ProceduralStream<IrisBiome> shoreBiomeStream;
private ProceduralStream<IrisBiome> baseBiomeStream;
private ProceduralStream<UUID> baseBiomeIDStream;
private ProceduralStream<LoaderBiome> trueBiomeStream;
private ProceduralStream<LoaderBiome> trueBiomeStreamNoFeatures;
private ProceduralStream<IrisBiome> trueBiomeStream;
private ProceduralStream<IrisBiome> trueBiomeStreamNoFeatures;
private ProceduralStream<Biome> trueBiomeDerivativeStream;
private ProceduralStream<Double> heightStream;
private ProceduralStream<Double> heightStreamNoFeatures;
@@ -95,9 +95,9 @@ public class IrisComplex implements DataProvider {
private ProceduralStream<IrisDecorator> shoreSurfaceDecoration;
private ProceduralStream<BlockData> rockStream;
private ProceduralStream<BlockData> fluidStream;
private LoaderBiome focus;
private IrisBiome focus;
public ProceduralStream<LoaderBiome> getBiomeStream(InferredType type) {
public ProceduralStream<IrisBiome> getBiomeStream(InferredType type) {
switch (type) {
case CAVE:
return caveBiomeStream;
@@ -123,7 +123,7 @@ public class IrisComplex implements DataProvider {
public IrisComplex(Engine engine, boolean simple) {
int cacheSize = 131072;
LoaderBiome emptyBiome = new LoaderBiome();
IrisBiome emptyBiome = new IrisBiome();
UUID focusUUID = UUID.nameUUIDFromBytes("focus".getBytes());
this.rng = new RNG(engine.getWorld().seed());
this.data = engine.getData();
@@ -131,13 +131,13 @@ public class IrisComplex implements DataProvider {
fluidHeight = engine.getDimension().getFluidHeight();
generators = new KList<>();
focus = engine.getFocus();
KMap<InferredType, ProceduralStream<LoaderBiome>> inferredStreams = new KMap<>();
KMap<InferredType, ProceduralStream<IrisBiome>> inferredStreams = new KMap<>();
if (focus != null) {
focus.setInferredType(InferredType.LAND);
}
LoaderRegion focusRegion = focus != null ? findRegion(focus, engine) : null;
IrisRegion focusRegion = focus != null ? findRegion(focus, engine) : null;
RNG rng = new RNG(engine.getWorld().seed());
//@builder
engine.getDimension().getRegions().forEach((i) -> data.getRegionLoader().load(i)
@@ -219,11 +219,11 @@ public class IrisComplex implements DataProvider {
bridgeStream.convertAware2D((t, x, z) -> inferredStreams.get(t).get(x, z))
.convertAware2D(this::implode).cache2D(cacheSize);
heightStream = ProceduralStream.of((x, z) -> {
LoaderBiome b = focus != null ? focus : baseBiomeStream.get(x, z);
IrisBiome b = focus != null ? focus : baseBiomeStream.get(x, z);
return getHeight(engine, b, x, z, engine.getWorld().seed(), true);
}, Interpolated.DOUBLE).clamp(0, engine.getHeight()).cache2D(cacheSize);
heightStreamNoFeatures = ProceduralStream.of((x, z) -> {
LoaderBiome b = focus != null ? focus : baseBiomeStream.get(x, z);
IrisBiome b = focus != null ? focus : baseBiomeStream.get(x, z);
return getHeight(engine, b, x, z, engine.getWorld().seed(), false);
}, Interpolated.DOUBLE).clamp(0, engine.getHeight()).cache2D(cacheSize);
slopeStream = heightStream.slope(3).cache2D(cacheSize);
@@ -242,7 +242,7 @@ public class IrisComplex implements DataProvider {
trueBiomeStream = focus != null ? ProceduralStream.of((x, y) -> focus, Interpolated.of(a -> 0D,
b -> focus)).convertAware2D((b, x, z) -> {
for (IrisFeaturePositional i : engine.getFramework().getEngineParallax().forEachFeature(x, z)) {
LoaderBiome bx = i.filter(x, z, b, rng);
IrisBiome bx = i.filter(x, z, b, rng);
if (bx != null) {
bx.setInferredType(b.getInferredType());
@@ -258,7 +258,7 @@ public class IrisComplex implements DataProvider {
regionStream.get(x, z), x, z, fluidHeight))
.convertAware2D((b, x, z) -> {
for (IrisFeaturePositional i : engine.getFramework().getEngineParallax().forEachFeature(x, z)) {
LoaderBiome bx = i.filter(x, z, b, rng);
IrisBiome bx = i.filter(x, z, b, rng);
if (bx != null) {
bx.setInferredType(b.getInferredType());
@@ -272,7 +272,7 @@ public class IrisComplex implements DataProvider {
trueBiomeStream = focus != null ? ProceduralStream.of((x, y) -> focus, Interpolated.of(a -> 0D,
b -> focus)).convertAware2D((b, x, z) -> {
for (IrisFeaturePositional i : engine.getFramework().getEngineParallax().forEachFeature(x, z)) {
LoaderBiome bx = i.filter(x, z, b, rng);
IrisBiome bx = i.filter(x, z, b, rng);
if (bx != null) {
bx.setInferredType(b.getInferredType());
@@ -288,7 +288,7 @@ public class IrisComplex implements DataProvider {
regionStream.get(x, z), x, z, fluidHeight))
.convertAware2D((b, x, z) -> {
for (IrisFeaturePositional i : engine.getFramework().getEngineParallax().forEachFeature(x, z)) {
LoaderBiome bx = i.filter(x, z, b, rng);
IrisBiome bx = i.filter(x, z, b, rng);
if (bx != null) {
bx.setInferredType(b.getInferredType());
@@ -306,7 +306,7 @@ public class IrisComplex implements DataProvider {
fixBiomeType(h, baseBiomeStream.get(x, z),
regionStream.get(x, z), x, z, fluidHeight))
.cache2D(cacheSize);
trueBiomeDerivativeStream = trueBiomeStream.convert(LoaderBiome::getDerivative).cache2D(cacheSize);
trueBiomeDerivativeStream = trueBiomeStream.convert(IrisBiome::getDerivative).cache2D(cacheSize);
heightFluidStream = heightStream.max(fluidHeight).cache2D(cacheSize);
maxHeightStream = ProceduralStream.ofDouble((x, z) -> height);
terrainSurfaceDecoration = trueBiomeStream
@@ -383,8 +383,8 @@ public class IrisComplex implements DataProvider {
});
}
private LoaderRegion findRegion(LoaderBiome focus, Engine engine) {
for (LoaderRegion i : engine.getDimension().getAllRegions(engine)) {
private IrisRegion findRegion(IrisBiome focus, Engine engine) {
for (IrisRegion i : engine.getDimension().getAllRegions(engine)) {
if (i.getAllBiomeIds().contains(focus.getLoadKey())) {
return i;
}
@@ -393,7 +393,7 @@ public class IrisComplex implements DataProvider {
return null;
}
private IrisDecorator decorateFor(LoaderBiome b, double x, double z, IrisDecorationPart part) {
private IrisDecorator decorateFor(IrisBiome b, double x, double z, IrisDecorationPart part) {
RNG rngc = chunkRngStream.get(x, z);
for (IrisDecorator i : b.getDecorators()) {
@@ -411,7 +411,7 @@ public class IrisComplex implements DataProvider {
return null;
}
private LoaderBiome fixBiomeType(Double height, LoaderBiome biome, LoaderRegion region, Double x, Double z, double fluidHeight) {
private IrisBiome fixBiomeType(Double height, IrisBiome biome, IrisRegion region, Double x, Double z, double fluidHeight) {
double sh = region.getShoreHeight(x, z);
if (height >= fluidHeight - 1 && height <= fluidHeight + sh && !biome.isShore()) {
@@ -433,14 +433,14 @@ public class IrisComplex implements DataProvider {
return biome;
}
private double getHeight(Engine engine, LoaderBiome b, double x, double z, long seed, boolean features) {
private double getHeight(Engine engine, IrisBiome b, double x, double z, long seed, boolean features) {
double h = 0;
for (LoaderGenerator gen : generators) {
for (IrisGenerator gen : generators) {
h += gen.getInterpolator().interpolate(x, z, (xx, zz) ->
{
try {
LoaderBiome bx = baseBiomeStream.get(xx, zz);
IrisBiome bx = baseBiomeStream.get(xx, zz);
return M.lerp(bx.getGenLinkMin(gen.getLoadKey()),
bx.getGenLinkMax(gen.getLoadKey()),
@@ -468,8 +468,8 @@ public class IrisComplex implements DataProvider {
return Math.min(engine.getHeight(), Math.max(noise.get(), 0));
}
private void registerGenerator(LoaderGenerator cachedGenerator) {
for (LoaderGenerator i : generators) {
private void registerGenerator(IrisGenerator cachedGenerator) {
for (IrisGenerator i : generators) {
if (i.getLoadKey().equals(cachedGenerator.getLoadKey())) {
return;
}
@@ -478,7 +478,7 @@ public class IrisComplex implements DataProvider {
generators.add(cachedGenerator);
}
private LoaderBiome implode(LoaderBiome b, Double x, Double z) {
private IrisBiome implode(IrisBiome b, Double x, Double z) {
if (b.getChildren().isEmpty()) {
return b;
}
@@ -486,7 +486,7 @@ public class IrisComplex implements DataProvider {
return implode(b, x, z, 3);
}
private LoaderBiome implode(LoaderBiome b, Double x, Double z, int max) {
private IrisBiome implode(IrisBiome b, Double x, Double z, int max) {
if (max < 0) {
return b;
}
@@ -496,9 +496,9 @@ public class IrisComplex implements DataProvider {
}
CNG childCell = b.getChildrenGenerator(rng, 123, b.getChildShrinkFactor());
KList<LoaderBiome> chx = b.getRealChildren(this).copy();
KList<IrisBiome> chx = b.getRealChildren(this).copy();
chx.add(b);
LoaderBiome biome = childCell.fitRarity(chx, x, z);
IrisBiome biome = childCell.fitRarity(chx, x, z);
biome.setInferredType(b.getInferredType());
return implode(biome, x, z, max - 1);
}

6
src/main/java/com/volmit/iris/engine/IrisEngine.java
View File

@@ -25,7 +25,7 @@ import com.volmit.iris.core.events.IrisEngineHotloadEvent;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.framework.*;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomePaletteLayer;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
@@ -142,7 +142,7 @@ public class IrisEngine extends BlockPopulator implements Engine {
}
private void computeBiomeMaxes() {
for (LoaderBiome i : getDimension().getAllBiomes(this)) {
for (IrisBiome i : getDimension().getAllBiomes(this)) {
double density = 0;
for (IrisObjectPlacement j : i.getObjects()) {
@@ -257,7 +257,7 @@ public class IrisEngine extends BlockPopulator implements Engine {
}
@Override
public LoaderBiome getFocus() {
public IrisBiome getFocus() {
if (getDimension().getFocus() == null || getDimension().getFocus().trim().isEmpty()) {
return null;
}

8
src/main/java/com/volmit/iris/engine/IrisEngineCompound.java
View File

@@ -26,7 +26,7 @@ import com.volmit.iris.engine.framework.EngineCompound;
import com.volmit.iris.engine.framework.EngineData;
import com.volmit.iris.engine.framework.EngineTarget;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimensionIndex;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.common.IrisWorld;
@@ -71,7 +71,7 @@ public class IrisEngineCompound implements EngineCompound {
private final KList<BlockPopulator> populators;
@Getter
private final LoaderDimension rootDimension;
private final IrisDimension rootDimension;
@Getter
private final int threadCount = -1;
@@ -80,7 +80,7 @@ public class IrisEngineCompound implements EngineCompound {
@Setter
private boolean studio;
public IrisEngineCompound(IrisWorld world, LoaderDimension rootDimension, IrisData data, int maximumThreads) {
public IrisEngineCompound(IrisWorld world, IrisDimension rootDimension, IrisData data, int maximumThreads) {
wallClock = new AtomicRollingSequence(32);
this.rootDimension = rootDimension;
Iris.info("Initializing Engine Composite for " + world.name());
@@ -115,7 +115,7 @@ public class IrisEngineCompound implements EngineCompound {
for (int i = 0; i < engines.length; i++) {
IrisDimensionIndex index = rootDimension.getDimensionalComposite().get(i);
LoaderDimension dimension = data.getDimensionLoader().load(index.getDimension());
IrisDimension dimension = data.getDimensionLoader().load(index.getDimension());
// TODO: WARNING HEIGHT
engines[i] = new IrisEngine(new EngineTarget(world, dimension, data.copy(), (int) Math.floor(256D * (index.getWeight() / totalWeight)), index.isInverted(), threadDist), this, i);
engines[i].setMinHeight(buf);

22
src/main/java/com/volmit/iris/engine/IrisWorldManager.java
View File

@@ -22,14 +22,14 @@ import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedWorldManager;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.block.IrisBlockDrops;
import com.volmit.iris.engine.object.common.IRare;
import com.volmit.iris.engine.object.engine.IrisEngineData;
import com.volmit.iris.engine.object.engine.IrisEngineSpawnerCooldown;
import com.volmit.iris.engine.object.entity.IrisEntitySpawn;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
import com.volmit.iris.util.format.Form;
@@ -165,8 +165,8 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
}
Chunk c = cc[RNG.r.nextInt(cc.length)];
LoaderBiome biome = getEngine().getSurfaceBiome(c);
LoaderRegion region = getEngine().getRegion(c);
IrisBiome biome = getEngine().getSurfaceBiome(c);
IrisRegion region = getEngine().getRegion(c);
spawnIn(c, biome, region, maxGroups);
chunkCooldowns.put(Cache.key(c), M.ms());
}
@@ -179,7 +179,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
energy = M.clip(energy, 1D, 1000D);
}
private void spawnIn(Chunk c, LoaderBiome biome, LoaderRegion region, int max) {
private void spawnIn(Chunk c, IrisBiome biome, IrisRegion region, int max) {
for(Entity i : c.getEntities())
{
if(i instanceof LivingEntity)
@@ -221,7 +221,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
}
}
private Stream<IrisEntitySpawn> stream(LoaderSpawner s) {
private Stream<IrisEntitySpawn> stream(IrisSpawner s) {
for (IrisEntitySpawn i : s.getSpawns()) {
i.setReferenceSpawner(s);
}
@@ -243,12 +243,12 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
return rarityTypes;
}
public boolean canSpawn(LoaderSpawner i) {
public boolean canSpawn(IrisSpawner i) {
return i.isValid(getEngine().getWorld().realWorld())
&& getCooldown(i).canSpawn(i.getMaximumRate());
}
private IrisEngineSpawnerCooldown getCooldown(LoaderSpawner i) {
private IrisEngineSpawnerCooldown getCooldown(IrisSpawner i) {
IrisEngineData ed = getEngine().getEngineData();
IrisEngineSpawnerCooldown cd = null;
@@ -298,7 +298,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
if (e.getBlock().getWorld().equals(getTarget().getWorld().realWorld()) && getEngine().contains(e.getBlock().getLocation())) {
KList<ItemStack> d = new KList<>();
Runnable drop = () -> J.s(() -> d.forEach((i) -> e.getBlock().getWorld().dropItemNaturally(e.getBlock().getLocation().clone().add(0.5, 0.5, 0.5), i)));
LoaderBiome b = getEngine().getBiome(e.getBlock().getLocation());
IrisBiome b = getEngine().getBiome(e.getBlock().getLocation());
for (IrisBlockDrops i : b.getBlockDrops()) {
if (i.shouldDropFor(e.getBlock().getBlockData(), getData())) {
@@ -315,7 +315,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
}
}
LoaderRegion r = getEngine().getRegion(e.getBlock().getLocation());
IrisRegion r = getEngine().getRegion(e.getBlock().getLocation());
for (IrisBlockDrops i : r.getBlockDrops()) {
if (i.shouldDropFor(e.getBlock().getBlockData(), getData())) {

4
src/main/java/com/volmit/iris/engine/actuator/IrisBiomeActuator.java
View File

@@ -25,7 +25,7 @@ import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedActuator;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.util.hunk.view.BiomeGridHunkView;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomeCustom;
import com.volmit.iris.util.documentation.BlockCoordinates;
import com.volmit.iris.util.math.RNG;
@@ -66,7 +66,7 @@ public class IrisBiomeActuator extends EngineAssignedActuator<Biome> {
public void onActuate(int x, int z, Hunk<Biome> h, boolean multicore) {
PrecisionStopwatch p = PrecisionStopwatch.start();
int zf, maxHeight;
LoaderBiome ib;
IrisBiome ib;
for (int xf = 0; xf < h.getWidth(); xf++) {
for (zf = 0; zf < h.getDepth(); zf++) {

4
src/main/java/com/volmit/iris/engine/actuator/IrisDecorantActuator.java
View File

@@ -23,7 +23,7 @@ import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedActuator;
import com.volmit.iris.engine.framework.EngineDecorator;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.carve.IrisCaveLayer;
import com.volmit.iris.util.documentation.BlockCoordinates;
import com.volmit.iris.util.math.RNG;
@@ -88,7 +88,7 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData> {
PrecisionStopwatch p = PrecisionStopwatch.start();
int j, realX, realZ, height;
LoaderBiome biome, cave;
IrisBiome biome, cave;
for (int i = 0; i < output.getWidth(); i++) {

4
src/main/java/com/volmit/iris/engine/actuator/IrisTerrainIslandActuator.java
View File

@@ -21,7 +21,7 @@ package com.volmit.iris.engine.actuator;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedActuator;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.documentation.BlockCoordinates;
import com.volmit.iris.util.math.RNG;
@@ -56,7 +56,7 @@ public class IrisTerrainIslandActuator extends EngineAssignedActuator<BlockData>
public void onActuate(int x, int z, Hunk<BlockData> h, boolean multicore) {
PrecisionStopwatch p = PrecisionStopwatch.start();
int i, zf, depth, surface, realX, realZ;
LoaderBiome biome;
IrisBiome biome;
KList<BlockData> blocks, fblocks;
int hi, lo;
double hh;

4
src/main/java/com/volmit/iris/engine/actuator/IrisTerrainNormalActuator.java
View File

@@ -21,7 +21,7 @@ package com.volmit.iris.engine.actuator;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedActuator;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.util.parallel.BurstExecutor;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.documentation.BlockCoordinates;
@@ -82,7 +82,7 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<BlockData>
@BlockCoordinates
public void terrainSliver(int x, int z, int xf, Hunk<BlockData> h) {
int i, depth, realX, realZ, hf, he, b, fdepth;
LoaderBiome biome;
IrisBiome biome;
KList<BlockData> blocks, fblocks;
for (int zf = 0; zf < h.getDepth(); zf++) {

77
src/main/java/com/volmit/iris/engine/data/DataPalette.java
View File

@@ -1,77 +0,0 @@
/*
* Iris is a World Generator for Minecraft Bukkit Servers
* Copyright (c) 2021 Arcane Arts (Volmit Software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.volmit.iris.engine.data;
import com.volmit.iris.util.collection.KList;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class DataPalette<T> {
private final KList<T> palette;
public DataPalette() {
this(new KList<>(16));
}
public DataPalette(KList<T> palette) {
this.palette = palette;
}
public KList<T> getPalette() {
return palette;
}
public int getIndex(T t) {
int v = 0;
synchronized (palette) {
v = palette.indexOf(t);
if (v == -1) {
v = palette.size();
palette.add(t);
}
}
return v;
}
public void write(IOAdapter<T> adapter, DataOutputStream dos) throws IOException {
synchronized (palette) {
dos.writeShort(getPalette().size() + Short.MIN_VALUE);
for (T t : palette) {
adapter.write(t, dos);
}
}
}
public static <T> DataPalette<T> getPalette(IOAdapter<T> adapter, DataInputStream din) throws IOException {
KList<T> palette = new KList<>();
int s = din.readShort() - Short.MIN_VALUE;
for (int i = 0; i < s; i++) {
palette.add(adapter.read(din));
}
return new DataPalette<>(palette);
}
}

4
src/main/java/com/volmit/iris/engine/data/chunk/MCATerrainChunk.java
View File

@@ -19,8 +19,8 @@
package com.volmit.iris.engine.data.chunk;
import com.volmit.iris.core.nms.BiomeBaseInjector;
import com.volmit.iris.engine.data.mca.Chunk;
import com.volmit.iris.engine.data.mca.NBTWorld;
import com.volmit.iris.util.nbt.mca.Chunk;
import com.volmit.iris.util.nbt.mca.NBTWorld;
import lombok.AllArgsConstructor;
import lombok.Builder;
import org.bukkit.Material;

4
src/main/java/com/volmit/iris/engine/decorator/IrisCeilingDecorator.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.BlockData;
@@ -34,7 +34,7 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
@BlockCoordinates
@Override
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
IrisDecorator decorator = getDecorator(biome, realX, realZ);
if (decorator != null) {

4
src/main/java/com/volmit/iris/engine/decorator/IrisEngineDecorator.java
View File

@@ -24,7 +24,7 @@ import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedComponent;
import com.volmit.iris.engine.framework.EngineDecorator;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.math.RNG;
@@ -44,7 +44,7 @@ public abstract class IrisEngineDecorator extends EngineAssignedComponent implem
this.rng = new RNG(getSeed() + 29356788 - (part.ordinal() * 10439677L));
}
protected IrisDecorator getDecorator(LoaderBiome biome, double realX, double realZ) {
protected IrisDecorator getDecorator(IrisBiome biome, double realX, double realZ) {
KList<IrisDecorator> v = new KList<>();
RNG rng = new RNG(Cache.key((int) realX, (int) realZ));

4
src/main/java/com/volmit/iris/engine/decorator/IrisSeaFloorDecorator.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.BlockData;
@@ -34,7 +34,7 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
@BlockCoordinates
@Override
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
IrisDecorator decorator = getDecorator(biome, realX, realZ);
if (decorator != null) {

4
src/main/java/com/volmit/iris/engine/decorator/IrisSeaSurfaceDecorator.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.BlockData;
@@ -34,7 +34,7 @@ public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
@BlockCoordinates
@Override
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
IrisDecorator decorator = getDecorator(biome, realX, realZ);
if (decorator != null) {

4
src/main/java/com/volmit/iris/engine/decorator/IrisShoreLineDecorator.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.BlockData;
@@ -34,7 +34,7 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
@BlockCoordinates
@Override
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
if (height == getDimension().getFluidHeight()) {
if (Math.round(getComplex().getHeightStream().get(realX1, realZ)) < getComplex().getFluidHeight() ||

4
src/main/java/com/volmit/iris/engine/decorator/IrisSurfaceDecorator.java
View File

@@ -24,7 +24,7 @@ import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.decoration.IrisDecorationPart;
import com.volmit.iris.engine.object.biome.InferredType;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.decoration.IrisDecorator;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.Bisected;
@@ -37,7 +37,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
@BlockCoordinates
@Override
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
if (biome.getInferredType().equals(InferredType.SHORE) && height < getDimension().getFluidHeight()) {
return;
}

54
src/main/java/com/volmit/iris/engine/framework/Engine.java
View File

@@ -23,16 +23,16 @@ import com.volmit.iris.core.gui.components.RenderType;
import com.volmit.iris.core.gui.components.Renderer;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.object.basic.IrisColor;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.loot.IrisLootReference;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.engine.object.loot.IrisLootMode;
import com.volmit.iris.engine.object.meta.InventorySlotType;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.engine.object.engine.IrisEngineData;
@@ -132,7 +132,7 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
return getTarget().getWorld();
}
default LoaderDimension getDimension() {
default IrisDimension getDimension() {
return getTarget().getDimension();
}
@@ -142,8 +142,8 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
@BlockCoordinates
default Color draw(double x, double z) {
LoaderRegion region = getRegion((int) x, (int) z);
LoaderBiome biome = getSurfaceBiome((int) x, (int) z);
IrisRegion region = getRegion((int) x, (int) z);
IrisBiome biome = getSurfaceBiome((int) x, (int) z);
int height = getHeight((int) x, (int) z);
double heightFactor = M.lerpInverse(0, getHeight(), height);
Color irc = region.getColor(this.getFramework().getComplex(), RenderType.BIOME);
@@ -157,7 +157,7 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
@BlockCoordinates
@Override
default LoaderRegion getRegion(int x, int z) {
default IrisRegion getRegion(int x, int z) {
return getFramework().getComplex().getRegionStream().get(x, z);
}
@@ -168,13 +168,13 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
@BlockCoordinates
@Override
default LoaderBiome getCaveBiome(int x, int z) {
default IrisBiome getCaveBiome(int x, int z) {
return getFramework().getComplex().getCaveBiomeStream().get(x, z);
}
@BlockCoordinates
@Override
default LoaderBiome getSurfaceBiome(int x, int z) {
default IrisBiome getSurfaceBiome(int x, int z) {
return getFramework().getComplex().getTrueBiomeStream().get(x, z);
}
@@ -262,7 +262,7 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
}
if (slot != null) {
KList<LoaderLootTable> tables = getLootTables(rx, block);
KList<IrisLootTable> tables = getLootTables(rx, block);
try {
InventoryHolder m = (InventoryHolder) block.getState();
@@ -315,7 +315,7 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
}
@Override
default void injectTables(KList<LoaderLootTable> list, IrisLootReference r) {
default void injectTables(KList<IrisLootTable> list, IrisLootReference r) {
if (r.getMode().equals(IrisLootMode.CLEAR) || r.getMode().equals(IrisLootMode.REPLACE)) {
list.clear();
}
@@ -325,7 +325,7 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
@BlockCoordinates
@Override
default KList<LoaderLootTable> getLootTables(RNG rng, Block b) {
default KList<IrisLootTable> getLootTables(RNG rng, Block b) {
int rx = b.getX();
int rz = b.getZ();
double he = getFramework().getComplex().getHeightStream().get(rx, rz);
@@ -333,16 +333,16 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
if (po != null && po.getPlacement() != null) {
if (B.isStorageChest(b.getBlockData())) {
LoaderLootTable table = po.getPlacement().getTable(b.getBlockData(), getData());
IrisLootTable table = po.getPlacement().getTable(b.getBlockData(), getData());
if (table != null) {
return new KList<>(table);
}
}
}
LoaderRegion region = getFramework().getComplex().getRegionStream().get(rx, rz);
LoaderBiome biomeSurface = getFramework().getComplex().getTrueBiomeStream().get(rx, rz);
LoaderBiome biomeUnder = b.getY() < he ? getFramework().getComplex().getCaveBiomeStream().get(rx, rz) : biomeSurface;
KList<LoaderLootTable> tables = new KList<>();
IrisRegion region = getFramework().getComplex().getRegionStream().get(rx, rz);
IrisBiome biomeSurface = getFramework().getComplex().getTrueBiomeStream().get(rx, rz);
IrisBiome biomeUnder = b.getY() < he ? getFramework().getComplex().getCaveBiomeStream().get(rx, rz) : biomeSurface;
KList<IrisLootTable> tables = new KList<>();
double multiplier = 1D * getDimension().getLoot().getMultiplier() * region.getLoot().getMultiplier() * biomeSurface.getLoot().getMultiplier() * biomeUnder.getLoot().getMultiplier();
injectTables(tables, getDimension().getLoot());
injectTables(tables, region.getLoot());
@@ -365,11 +365,11 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
}
@Override
default void addItems(boolean debug, Inventory inv, RNG rng, KList<LoaderLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf) {
default void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf) {
KList<ItemStack> items = new KList<>();
int b = 4;
for (LoaderLootTable i : tables) {
for (IrisLootTable i : tables) {
b++;
items.addAll(i.getLoot(debug, items.isEmpty(), rng, slot, x, y, z, b + b, mgf + b));
}
@@ -402,12 +402,12 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
}
@BlockCoordinates
default LoaderBiome getBiome(Location l) {
default IrisBiome getBiome(Location l) {
return getBiome(l.getBlockX(), l.getBlockY(), l.getBlockZ());
}
@BlockCoordinates
default LoaderRegion getRegion(Location l) {
default IrisRegion getRegion(Location l) {
return getRegion(l.getBlockX(), l.getBlockZ());
}
@@ -416,15 +416,15 @@ public interface Engine extends DataProvider, Fallible, GeneratorAccess, LootPro
return l.getBlockY() >= getMinHeight() && l.getBlockY() <= getMaxHeight();
}
LoaderBiome getFocus();
IrisBiome getFocus();
IrisEngineData getEngineData();
default LoaderBiome getSurfaceBiome(Chunk c) {
default IrisBiome getSurfaceBiome(Chunk c) {
return getSurfaceBiome((c.getX() << 4) + 8, (c.getZ() << 4) + 8);
}
default LoaderRegion getRegion(Chunk c) {
default IrisRegion getRegion(Chunk c) {
return getRegion((c.getX() << 4) + 8, (c.getZ() << 4) + 8);
}
}

4
src/main/java/com/volmit/iris/engine/framework/EngineComponent.java
View File

@@ -21,7 +21,7 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.IrisComplex;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.parallax.ParallaxAccess;
import com.volmit.iris.util.math.RollingSequence;
import org.bukkit.event.Listener;
@@ -64,7 +64,7 @@ public interface EngineComponent {
return getEngine().getTarget();
}
default LoaderDimension getDimension() {
default IrisDimension getDimension() {
return getEngine().getDimension();
}

42
src/main/java/com/volmit/iris/engine/framework/EngineCompositeGenerator.java
View File

@@ -25,15 +25,15 @@ import com.volmit.iris.core.pregenerator.PregenListener;
import com.volmit.iris.core.pregenerator.PregenTask;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.IrisEngineCompound;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.data.chunk.MCATerrainChunk;
import com.volmit.iris.engine.data.chunk.TerrainChunk;
import com.volmit.iris.engine.data.mca.NBTWorld;
import com.volmit.iris.engine.data.nbt.tag.CompoundTag;
import com.volmit.iris.util.nbt.mca.NBTWorld;
import com.volmit.iris.util.nbt.tag.CompoundTag;
import com.volmit.iris.engine.framework.headless.HeadlessGenerator;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.util.parallel.BurstExecutor;
@@ -202,11 +202,11 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
return false;
}
private synchronized LoaderDimension getDimension(IrisWorld world) {
private synchronized IrisDimension getDimension(IrisWorld world) {
String query = dimensionQuery;
query = Iris.linkMultiverseCore.getWorldNameType(world.name(), query);
LoaderDimension dim = null;
IrisDimension dim = null;
if (query == null) {
File iris = new File(world.worldFolder(), "iris");
@@ -253,7 +253,7 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
}
if (production) {
LoaderDimension od = dim;
IrisDimension od = dim;
dim = new IrisData(getDataFolder(world)).getDimensionLoader().load(od.getLoadKey());
if (dim == null) {
@@ -270,9 +270,9 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
return dim;
}
private synchronized LoaderDimension getDimension(String world) {
private synchronized IrisDimension getDimension(String world) {
String query = dimensionQuery;
LoaderDimension dim = null;
IrisDimension dim = null;
if (query == null) {
File iris = new File(world + "/iris");
@@ -319,7 +319,7 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
}
if (production) {
LoaderDimension od = dim;
IrisDimension od = dim;
dim = new IrisData(getDataFolder(world)).getDimensionLoader().load(od.getLoadKey());
if (dim == null) {
@@ -345,7 +345,7 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
try {
initialized.set(true);
LoaderDimension dim = getDimension(world);
IrisDimension dim = getDimension(world);
IrisData data = production ? new IrisData(getDataFolder(world)) : dim.getLoader().copy();
compound.set(new IrisEngineCompound(world, dim, data, IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getEngineThreadCount())));
compound.get().setStudio(!production);
@@ -572,7 +572,7 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
try {
int ox = x << 4;
int oz = z << 4;
com.volmit.iris.engine.data.mca.Chunk chunk = writer.getChunk(x, z);
com.volmit.iris.util.nbt.mca.Chunk chunk = writer.getChunk(x, z);
generateChunkRawData(w, x, z, MCATerrainChunk.builder()
.writer(writer).ox(ox).oz(oz).mcaChunk(chunk)
.minHeight(w.minHeight()).maxHeight(w.maxHeight())
@@ -584,7 +584,7 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
e.printStackTrace();
Iris.reportErrorChunk(x, z, e, "MCA");
Iris.error("======================================");
com.volmit.iris.engine.data.mca.Chunk chunk = writer.getChunk(x, z);
com.volmit.iris.util.nbt.mca.Chunk chunk = writer.getChunk(x, z);
CompoundTag c = NBTWorld.getCompound(ERROR_BLOCK);
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
@@ -673,12 +673,12 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
}
@Override
public LoaderBiome getBiome(int x, int z) {
public IrisBiome getBiome(int x, int z) {
return getBiome(x, 0, z);
}
@Override
public LoaderBiome getCaveBiome(int x, int z) {
public IrisBiome getCaveBiome(int x, int z) {
return getCaveBiome(x, 0, z);
}
@@ -693,13 +693,13 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
}
@Override
public LoaderBiome getBiome(int x, int y, int z) {
public IrisBiome getBiome(int x, int y, int z) {
// TODO: REMOVE GET ABS BIOME OR THIS ONE
return getEngineAccess(y).getBiome(x, y - getComposite().getEngineForHeight(y).getMinHeight(), z);
}
@Override
public LoaderBiome getCaveBiome(int x, int y, int z) {
public IrisBiome getCaveBiome(int x, int y, int z) {
return getEngineAccess(y).getCaveBiome(x, z);
}
@@ -792,12 +792,12 @@ public class EngineCompositeGenerator extends ChunkGenerator implements IrisAcce
return false;
}
public KList<LoaderBiome> getAllBiomes(String worldName) {
public KList<IrisBiome> getAllBiomes(String worldName) {
if (getComposite() != null) {
return getComposite().getAllBiomes();
} else {
KMap<String, LoaderBiome> v = new KMap<>();
LoaderDimension dim = getDimension(worldName);
KMap<String, IrisBiome> v = new KMap<>();
IrisDimension dim = getDimension(worldName);
dim.getAllAnyBiomes().forEach((i) -> v.put(i.getLoadKey(), i));
try {

14
src/main/java/com/volmit/iris/engine/framework/EngineCompound.java
View File

@@ -21,10 +21,10 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.actuator.IrisTerrainNormalActuator;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.util.parallel.MultiBurst;
@@ -39,7 +39,7 @@ import org.bukkit.generator.BlockPopulator;
import java.util.List;
public interface EngineCompound extends Listener, Hotloadable, DataProvider {
LoaderDimension getRootDimension();
IrisDimension getRootDimension();
void generate(int x, int z, Hunk<BlockData> blocks, Hunk<BlockData> postblocks, Hunk<Biome> biomes, boolean multicore);
@@ -133,10 +133,10 @@ public interface EngineCompound extends Listener, Hotloadable, DataProvider {
Engine getDefaultEngine();
default KList<LoaderBiome> getAllBiomes() {
KMap<String, LoaderBiome> v = new KMap<>();
default KList<IrisBiome> getAllBiomes() {
KMap<String, IrisBiome> v = new KMap<>();
LoaderDimension dim = getRootDimension();
IrisDimension dim = getRootDimension();
dim.getAllBiomes(this).forEach((i) -> v.put(i.getLoadKey(), i));
try {

8
src/main/java/com/volmit/iris/engine/framework/EngineDecorator.java
View File

@@ -18,19 +18,19 @@
package com.volmit.iris.engine.framework;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.util.documentation.BlockCoordinates;
import org.bukkit.block.data.BlockData;
public interface EngineDecorator extends EngineComponent {
@BlockCoordinates
void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, LoaderBiome biome, int height, int max);
void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max);
@BlockCoordinates
default void decorate(int x, int z, int realX, int realZ, Hunk<BlockData> data, LoaderBiome biome, int height, int max) {
default void decorate(int x, int z, int realX, int realZ, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
decorate(x, z, realX, realX, realX, realZ, realZ, realZ, data, biome, height, max);
}

2
src/main/java/com/volmit/iris/engine/framework/EngineFramework.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.IrisComplex;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import org.bukkit.block.Biome;
import org.bukkit.block.data.BlockData;

76
src/main/java/com/volmit/iris/engine/framework/EngineParallaxManager.java
View File

@@ -22,21 +22,21 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.IrisComplex;
import com.volmit.iris.engine.data.cache.Cache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomeMutation;
import com.volmit.iris.engine.object.deposits.IrisDepositGenerator;
import com.volmit.iris.engine.object.feature.IrisFeature;
import com.volmit.iris.engine.object.feature.IrisFeaturePositional;
import com.volmit.iris.engine.object.feature.IrisFeaturePotential;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructurePlacement;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.objects.IrisObjectScale;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.jigsaw.PlannedStructure;
import com.volmit.iris.engine.object.common.IObjectPlacer;
@@ -90,8 +90,8 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
return getEngine().getFramework().getComplex();
}
default KList<LoaderRegion> getAllRegions() {
KList<LoaderRegion> r = new KList<>();
default KList<IrisRegion> getAllRegions() {
KList<IrisRegion> r = new KList<>();
for (String i : getEngine().getDimension().getRegions()) {
r.add(getEngine().getData().getRegionLoader().load(i));
@@ -108,10 +108,10 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
return r;
}
default KList<LoaderBiome> getAllBiomes() {
KList<LoaderBiome> r = new KList<>();
default KList<IrisBiome> getAllBiomes() {
KList<IrisBiome> r = new KList<>();
for (LoaderRegion i : getAllRegions()) {
for (IrisRegion i : getAllRegions()) {
r.addAll(i.getAllBiomes(this));
}
@@ -299,8 +299,8 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
getParallaxAccess().setFeatureGenerated(xx, zz);
burst.queue(() -> {
RNG rng = new RNG(Cache.key(xx, zz) + getEngine().getTarget().getWorld().seed());
LoaderRegion region = getComplex().getRegionStream().get(xxx, zzz);
LoaderBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xxx, zzz);
IrisRegion region = getComplex().getRegionStream().get(xxx, zzz);
IrisBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xxx, zzz);
generateParallaxFeatures(rng, xx, zz, region, biome);
});
}
@@ -361,8 +361,8 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
int xx = x << 4;
int zz = z << 4;
RNG rng = new RNG(Cache.key(x, z)).nextParallelRNG(getEngine().getTarget().getWorld().seed());
LoaderRegion region = getComplex().getRegionStream().get(xx + 8, zz + 8);
LoaderBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xx + 8, zz + 8);
IrisRegion region = getComplex().getRegionStream().get(xx + 8, zz + 8);
IrisBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xx + 8, zz + 8);
after.addAll(generateParallaxJigsaw(rng, x, z, biome, region));
generateParallaxSurface(rng, x, z, biome, region, true);
generateParallaxMutations(rng, x, z, true);
@@ -380,14 +380,14 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
int zz = z << 4;
getParallaxAccess().setParallaxGenerated(x, z);
RNG rng = new RNG(Cache.key(x, z)).nextParallelRNG(getEngine().getTarget().getWorld().seed());
LoaderBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xx + 8, zz + 8);
LoaderRegion region = getComplex().getRegionStream().get(xx + 8, zz + 8);
IrisBiome biome = getComplex().getTrueBiomeStreamNoFeatures().get(xx + 8, zz + 8);
IrisRegion region = getComplex().getRegionStream().get(xx + 8, zz + 8);
generateParallaxSurface(rng, x, z, biome, region, false);
generateParallaxMutations(rng, x, z, false);
}
@ChunkCoordinates
default void generateParallaxFeatures(RNG rng, int cx, int cz, LoaderRegion region, LoaderBiome biome) {
default void generateParallaxFeatures(RNG rng, int cx, int cz, IrisRegion region, IrisBiome biome) {
for (IrisFeaturePotential i : getEngine().getDimension().getFeatures()) {
placeZone(rng, cx, cz, i);
}
@@ -415,7 +415,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
generateParallaxLayer(x, z, false);
}
default KList<Runnable> placeStructure(IrisPosition position, LoaderJigsawStructure structure, RNG rng) {
default KList<Runnable> placeStructure(IrisPosition position, IrisJigsawStructure structure, RNG rng) {
KList<Runnable> placeAfter = new KList<>();
if (structure == null) {
@@ -435,7 +435,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
return placeAfter;
}
default KList<Runnable> generateParallaxJigsaw(RNG rng, int x, int z, LoaderBiome biome, LoaderRegion region) {
default KList<Runnable> generateParallaxJigsaw(RNG rng, int x, int z, IrisBiome biome, IrisRegion region) {
KList<Runnable> placeAfter = new KList<>();
if (getEngine().getDimension().isPlaceObjects()) {
@@ -447,7 +447,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
if (poss != null) {
for (Position2 pos : poss) {
if (x == pos.getX() >> 4 && z == pos.getZ() >> 4) {
LoaderJigsawStructure structure = getData().getJigsawStructureLoader().load(getEngine().getDimension().getStronghold());
IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(getEngine().getDimension().getStronghold());
placeAfter.addAll(placeStructure(pos.toIris(), structure, rng));
placed = true;
}
@@ -459,7 +459,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
for (IrisJigsawStructurePlacement i : biome.getJigsawStructures()) {
if (rng.nextInt(i.getRarity()) == 0) {
IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
LoaderJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
placeAfter.addAll(placeStructure(position, structure, rng));
placed = true;
}
@@ -470,7 +470,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
for (IrisJigsawStructurePlacement i : region.getJigsawStructures()) {
if (rng.nextInt(i.getRarity()) == 0) {
IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
LoaderJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
placeAfter.addAll(placeStructure(position, structure, rng));
placed = true;
}
@@ -481,7 +481,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
for (IrisJigsawStructurePlacement i : getEngine().getDimension().getJigsawStructures()) {
if (rng.nextInt(i.getRarity()) == 0) {
IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
LoaderJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
placeAfter.addAll(placeStructure(position, structure, rng));
placed = true;
}
@@ -492,7 +492,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
return placeAfter;
}
default void generateParallaxSurface(RNG rng, int x, int z, LoaderBiome biome, LoaderRegion region, boolean useFeatures) {
default void generateParallaxSurface(RNG rng, int x, int z, IrisBiome biome, IrisRegion region, boolean useFeatures) {
for (IrisObjectPlacement i : biome.getSurfaceObjects()) {
if (i.usesFeatures() != useFeatures) {
@@ -539,8 +539,8 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
searching:
for (IrisBiomeMutation k : getEngine().getDimension().getMutations()) {
for (int l = 0; l < k.getChecks(); l++) {
LoaderBiome sa = getComplex().getTrueBiomeStreamNoFeatures().get(((x * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()), ((z * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()));
LoaderBiome sb = getComplex().getTrueBiomeStreamNoFeatures().get(((x * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()), ((z * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()));
IrisBiome sa = getComplex().getTrueBiomeStreamNoFeatures().get(((x * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()), ((z * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()));
IrisBiome sb = getComplex().getTrueBiomeStreamNoFeatures().get(((x * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()), ((z * 16) + rng.nextInt(16)) + rng.i(-k.getRadius(), k.getRadius()));
if (sa.getLoadKey().equals(sb.getLoadKey())) {
continue;
@@ -565,7 +565,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
place(rng, x, -1, z, objectPlacement);
}
default void placePiece(RNG rng, int xx, int forceY, int zz, LoaderObject v, IrisObjectPlacement p) {
default void placePiece(RNG rng, int xx, int forceY, int zz, IrisObject v, IrisObjectPlacement p) {
int id = rng.i(0, Integer.MAX_VALUE);
int maxf = 10000;
AtomicBoolean pl = new AtomicBoolean(false);
@@ -612,7 +612,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
default void place(RNG rng, int x, int forceY, int z, IrisObjectPlacement objectPlacement) {
placing:
for (int i = 0; i < objectPlacement.getDensity(); i++) {
LoaderObject v = objectPlacement.getScale().get(rng, objectPlacement.getObject(getComplex(), rng));
IrisObject v = objectPlacement.getScale().get(rng, objectPlacement.getObject(getComplex(), rng));
if (v == null) {
return;
}
@@ -656,7 +656,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
}
}
default void updateParallaxChunkObjectData(int minY, int maxY, int x, int z, LoaderObject v) {
default void updateParallaxChunkObjectData(int minY, int maxY, int x, int z, IrisObject v) {
ParallaxChunkMeta meta = getParallaxAccess().getMetaRW(x >> 4, z >> 4);
meta.setObjects(true);
meta.setMaxObject(Math.max(maxY, meta.getMaxObject()));
@@ -676,10 +676,10 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
int z = zg.get();
if (getEngine().getDimension().isPlaceObjects()) {
KList<LoaderRegion> r = getAllRegions();
KList<LoaderBiome> b = getAllBiomes();
KList<IrisRegion> r = getAllRegions();
KList<IrisBiome> b = getAllBiomes();
for (LoaderBiome i : b) {
for (IrisBiome i : b) {
for (IrisObjectPlacement j : i.getObjects()) {
if (j.getScale().canScaleBeyond()) {
scalars.put(j.getScale(), j.getPlace());
@@ -693,7 +693,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
}
}
for (LoaderRegion i : r) {
for (IrisRegion i : r) {
for (IrisObjectPlacement j : i.getObjects()) {
if (j.getScale().canScaleBeyond()) {
scalars.put(j.getScale(), j.getPlace());
@@ -733,7 +733,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
}
try {
return LoaderObject.sampleSize(getData().getObjectLoader().findFile(i));
return IrisObject.sampleSize(getData().getObjectLoader().findFile(i));
} catch (IOException ex) {
Iris.reportError(ex);
ex.printStackTrace();
@@ -773,7 +773,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
}
try {
return LoaderObject.sampleSize(getData().getObjectLoader().findFile(j));
return IrisObject.sampleSize(getData().getObjectLoader().findFile(j));
} catch (IOException ioException) {
Iris.reportError(ioException);
ioException.printStackTrace();
@@ -814,7 +814,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
z = Math.max(max, z);
}
for (LoaderRegion v : r) {
for (IrisRegion v : r) {
for (IrisDepositGenerator i : v.getDeposits()) {
int max = i.getMaxDimension();
x = Math.max(max, x);
@@ -822,7 +822,7 @@ public interface EngineParallaxManager extends DataProvider, IObjectPlacer {
}
}
for (LoaderBiome v : b) {
for (IrisBiome v : b) {
for (IrisDepositGenerator i : v.getDeposits()) {
int max = i.getMaxDimension();
x = Math.max(max, x);

8
src/main/java/com/volmit/iris/engine/framework/EnginePlayer.java
View File

@@ -19,9 +19,9 @@
package com.volmit.iris.engine.framework;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.meta.IrisEffect;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.math.M;
import com.volmit.iris.util.scheduling.J;
import lombok.Data;
@@ -32,8 +32,8 @@ import org.bukkit.entity.Player;
public class EnginePlayer {
private final Engine engine;
private final Player player;
private LoaderBiome biome;
private LoaderRegion region;
private IrisBiome biome;
private IrisRegion region;
private Location lastLocation;
private long lastSample;

8
src/main/java/com/volmit/iris/engine/framework/EngineTarget.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.engine.parallax.ParallaxWorld;
import com.volmit.iris.util.parallel.MultiBurst;
@@ -32,14 +32,14 @@ import java.io.File;
public class EngineTarget {
private final MultiBurst parallaxBurster;
private final MultiBurst burster;
private final LoaderDimension dimension;
private final IrisDimension dimension;
private IrisWorld world;
private final int height;
private final IrisData data;
private final ParallaxWorld parallaxWorld;
private final boolean inverted;
public EngineTarget(IrisWorld world, LoaderDimension dimension, IrisData data, int height, boolean inverted, int threads) {
public EngineTarget(IrisWorld world, IrisDimension dimension, IrisData data, int height, boolean inverted, int threads) {
this.world = world;
this.height = height;
this.dimension = dimension;
@@ -50,7 +50,7 @@ public class EngineTarget {
this.parallaxWorld = new ParallaxWorld(parallaxBurster, 256, new File(world.worldFolder(), "iris/" + dimension.getLoadKey() + "/parallax"));
}
public EngineTarget(IrisWorld world, LoaderDimension dimension, IrisData data, int height, int threads) {
public EngineTarget(IrisWorld world, IrisDimension dimension, IrisData data, int height, int threads) {
this(world, dimension, data, height, false, threads);
}

18
src/main/java/com/volmit/iris/engine/framework/GeneratorAccess.java
View File

@@ -20,26 +20,26 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.core.gui.components.Renderer;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.parallax.ParallaxAccess;
public interface GeneratorAccess extends DataProvider, Renderer {
LoaderRegion getRegion(int x, int z);
IrisRegion getRegion(int x, int z);
ParallaxAccess getParallaxAccess();
IrisData getData();
LoaderBiome getCaveBiome(int x, int z);
IrisBiome getCaveBiome(int x, int z);
LoaderBiome getSurfaceBiome(int x, int z);
IrisBiome getSurfaceBiome(int x, int z);
int getHeight(int x, int z);
default LoaderBiome getBiome(int x, int y, int z) {
default IrisBiome getBiome(int x, int y, int z) {
if (y <= getHeight(x, z) - 2) {
return getCaveBiome(x, z);
}
@@ -57,7 +57,7 @@ public interface GeneratorAccess extends DataProvider, Renderer {
String[] v = objectAt.split("\\Q@\\E");
String object = v[0];
int id = Integer.parseInt(v[1]);
LoaderRegion region = getRegion(x, z);
IrisRegion region = getRegion(x, z);
for (IrisObjectPlacement i : region.getObjects()) {
if (i.getPlace().contains(object)) {
@@ -65,7 +65,7 @@ public interface GeneratorAccess extends DataProvider, Renderer {
}
}
LoaderBiome biome = getBiome(x, y, z);
IrisBiome biome = getBiome(x, y, z);
for (IrisObjectPlacement i : biome.getObjects()) {
if (i.getPlace().contains(object)) {

32
src/main/java/com/volmit/iris/engine/framework/IrisAccess.java
View File

@@ -21,11 +21,11 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.Iris;
import com.volmit.iris.core.pregenerator.PregenListener;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.engine.data.mca.NBTWorld;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.util.nbt.mca.NBTWorld;
import com.volmit.iris.engine.framework.headless.HeadlessGenerator;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.util.parallel.MultiBurst;
import com.volmit.iris.util.collection.KList;
@@ -71,29 +71,29 @@ public interface IrisAccess extends Hotloadable, DataProvider {
* @param l the location
* @return the biome
*/
default LoaderBiome getBiome(Location l) {
default IrisBiome getBiome(Location l) {
return getBiome(l.toVector());
}
default LoaderRegion getRegion(int x, int y, int z) {
default IrisRegion getRegion(int x, int y, int z) {
return getEngineAccess(y).getRegion(x, z);
}
default LoaderRegion getRegion(Location l) {
default IrisRegion getRegion(Location l) {
return getRegion(l.getBlockX(), l.getBlockY(), l.getBlockZ());
}
default LoaderBiome getBiome(Vector l) {
default IrisBiome getBiome(Vector l) {
return getBiome(l.getBlockX(), l.getBlockY(), l.getBlockZ());
}
LoaderBiome getBiome(int x, int y, int z);
IrisBiome getBiome(int x, int y, int z);
LoaderBiome getCaveBiome(int x, int y, int z);
IrisBiome getCaveBiome(int x, int y, int z);
LoaderBiome getBiome(int x, int z);
IrisBiome getBiome(int x, int z);
LoaderBiome getCaveBiome(int x, int z);
IrisBiome getCaveBiome(int x, int z);
GeneratorAccess getEngineAccess(int y);
@@ -117,7 +117,7 @@ public interface IrisAccess extends Hotloadable, DataProvider {
boolean isStudio();
default Location lookForBiome(LoaderBiome biome, long timeout, Consumer<Integer> triesc) {
default Location lookForBiome(IrisBiome biome, long timeout, Consumer<Integer> triesc) {
if (!getCompound().getWorld().hasRealWorld()) {
Iris.error("Cannot GOTO without a bound world (headless mode)");
return null;
@@ -146,7 +146,7 @@ public interface IrisAccess extends Hotloadable, DataProvider {
J.a(() -> {
try {
Engine e;
LoaderBiome b;
IrisBiome b;
int x, z;
while (!found.get() && running.get()) {
@@ -198,7 +198,7 @@ public interface IrisAccess extends Hotloadable, DataProvider {
return location.get();
}
default Location lookForRegion(LoaderRegion reg, long timeout, Consumer<Integer> triesc) {
default Location lookForRegion(IrisRegion reg, long timeout, Consumer<Integer> triesc) {
if (!getCompound().getWorld().hasRealWorld()) {
Iris.error("Cannot GOTO without a bound world (headless mode)");
return null;
@@ -227,7 +227,7 @@ public interface IrisAccess extends Hotloadable, DataProvider {
for (int i = 0; i < cpus; i++) {
J.a(() -> {
Engine e;
LoaderRegion b;
IrisRegion b;
int x, z;
while (!found.get() && running.get()) {

8
src/main/java/com/volmit/iris/engine/framework/LootProvider.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.framework;
import com.volmit.iris.engine.object.meta.InventorySlotType;
import com.volmit.iris.engine.object.loot.IrisLootReference;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.math.RNG;
import org.bukkit.block.Block;
@@ -29,9 +29,9 @@ import org.bukkit.inventory.Inventory;
public interface LootProvider {
void scramble(Inventory inventory, RNG rng);
void injectTables(KList<LoaderLootTable> list, IrisLootReference r);
void injectTables(KList<IrisLootTable> list, IrisLootReference r);
KList<LoaderLootTable> getLootTables(RNG rng, Block b);
KList<IrisLootTable> getLootTables(RNG rng, Block b);
void addItems(boolean debug, Inventory inv, RNG rng, KList<LoaderLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf);
void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf);
}

4
src/main/java/com/volmit/iris/engine/framework/PlacedObject.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.framework;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import lombok.AllArgsConstructor;
import lombok.Data;
@@ -31,7 +31,7 @@ public class PlacedObject {
@Nullable
private IrisObjectPlacement placement;
@Nullable
private LoaderObject object;
private IrisObject object;
private int id;
private int xx;
private int zz;

2
src/main/java/com/volmit/iris/engine/framework/PregeneratedData.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.framework;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.data.chunk.TerrainChunk;
import com.volmit.iris.util.hunk.Hunk;
import lombok.Data;

4
src/main/java/com/volmit/iris/engine/framework/headless/HeadlessGenerator.java
View File

@@ -20,8 +20,8 @@ package com.volmit.iris.engine.framework.headless;
import com.volmit.iris.core.IrisSettings;
import com.volmit.iris.core.pregenerator.PregenListener;
import com.volmit.iris.engine.data.mca.MCAUtil;
import com.volmit.iris.engine.data.mca.NBTWorld;
import com.volmit.iris.util.nbt.mca.MCAUtil;
import com.volmit.iris.util.nbt.mca.NBTWorld;
import com.volmit.iris.engine.framework.EngineCompositeGenerator;
import com.volmit.iris.util.parallel.MultiBurst;
import com.volmit.iris.util.collection.KList;

8
src/main/java/com/volmit/iris/engine/framework/headless/HeadlessWorld.java
View File

@@ -22,7 +22,7 @@ import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.tools.IrisWorlds;
import com.volmit.iris.engine.framework.EngineCompositeGenerator;
import com.volmit.iris.engine.object.dimensional.LoaderDimension;
import com.volmit.iris.engine.object.dimensional.IrisDimension;
import com.volmit.iris.engine.object.common.IrisWorld;
import com.volmit.iris.util.plugin.VolmitSender;
import lombok.Data;
@@ -35,16 +35,16 @@ import java.io.File;
@Data
@SuppressWarnings("ResultOfMethodCallIgnored")
public class HeadlessWorld {
private final LoaderDimension dimension;
private final IrisDimension dimension;
private final String worldName;
private final IrisWorld world;
private boolean studio = false;
public HeadlessWorld(String worldName, LoaderDimension dimension, long seed) {
public HeadlessWorld(String worldName, IrisDimension dimension, long seed) {
this(worldName, dimension, seed, false);
}
public HeadlessWorld(String worldName, LoaderDimension dimension, long seed, boolean studio) {
public HeadlessWorld(String worldName, IrisDimension dimension, long seed, boolean studio) {
this.worldName = worldName;
this.dimension = dimension;
this.studio = studio;

20
src/main/java/com/volmit/iris/engine/jigsaw/PlannedPiece.java
View File

@@ -24,11 +24,11 @@ import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.common.IObjectPlacer;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPieceConnector;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.engine.object.meta.InventorySlotType;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectRotation;
import com.volmit.iris.engine.object.tile.TileData;
import com.volmit.iris.util.collection.KList;
@@ -49,9 +49,9 @@ import org.bukkit.util.BlockVector;
@Data
public class PlannedPiece {
private IrisPosition position;
private LoaderObject object;
private LoaderObject ogObject;
private LoaderJigsawPiece piece;
private IrisObject object;
private IrisObject ogObject;
private IrisJigsawPiece piece;
private IrisObjectRotation rotation;
private IrisData data;
private KList<IrisJigsawPieceConnector> connected;
@@ -59,15 +59,15 @@ public class PlannedPiece {
private AxisAlignedBB box;
private PlannedStructure structure;
public PlannedPiece(PlannedStructure structure, IrisPosition position, LoaderJigsawPiece piece) {
public PlannedPiece(PlannedStructure structure, IrisPosition position, IrisJigsawPiece piece) {
this(structure, position, piece, 0, 0, 0);
}
public PlannedPiece(PlannedStructure structure, IrisPosition position, LoaderJigsawPiece piece, int rx, int ry, int rz) {
public PlannedPiece(PlannedStructure structure, IrisPosition position, IrisJigsawPiece piece, int rx, int ry, int rz) {
this(structure, position, piece, IrisObjectRotation.of(rx * 90D, ry * 90D, rz * 90D));
}
public PlannedPiece(PlannedStructure structure, IrisPosition position, LoaderJigsawPiece piece, IrisObjectRotation rot) {
public PlannedPiece(PlannedStructure structure, IrisPosition position, IrisJigsawPiece piece, IrisObjectRotation rot) {
this.structure = structure;
this.position = position;
this.data = piece.getLoader();
@@ -187,7 +187,7 @@ public class PlannedPiece {
if (a != null && getPiece().getPlacementOptions().getLoot().isNotEmpty() &&
block.getState() instanceof InventoryHolder) {
LoaderLootTable table = getPiece().getPlacementOptions().getTable(block.getBlockData(), getData());
IrisLootTable table = getPiece().getPlacementOptions().getTable(block.getBlockData(), getData());
if (table == null) return;
Engine engine = a.getCompound().getEngineForHeight(y);
engine.addItems(false, ((InventoryHolder) block.getState()).getInventory(),

36
src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java
View File

@@ -27,12 +27,12 @@ import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.util.interpolation.InterpolationMethod;
import com.volmit.iris.engine.object.common.IObjectPlacer;
import com.volmit.iris.engine.object.entity.LoaderEntity;
import com.volmit.iris.engine.object.entity.IrisEntity;
import com.volmit.iris.engine.object.feature.IrisFeature;
import com.volmit.iris.engine.object.feature.IrisFeaturePositional;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPiece;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawPieceConnector;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.objects.*;
import com.volmit.iris.engine.parallax.ParallaxChunkMeta;
import com.volmit.iris.util.collection.KList;
@@ -46,20 +46,20 @@ import org.bukkit.entity.Entity;
@Data
public class PlannedStructure {
private KList<PlannedPiece> pieces;
private LoaderJigsawStructure structure;
private IrisJigsawStructure structure;
private IrisPosition position;
private IrisData data;
private RNG rng;
private boolean verbose;
private boolean terminating;
private static transient ConcurrentLinkedHashMap<String, LoaderObject> objectRotationCache
= new ConcurrentLinkedHashMap.Builder<String, LoaderObject>()
private static transient ConcurrentLinkedHashMap<String, IrisObject> objectRotationCache
= new ConcurrentLinkedHashMap.Builder<String, IrisObject>()
.initialCapacity(64)
.maximumWeightedCapacity(1024)
.concurrencyLevel(32)
.build();
public PlannedStructure(LoaderJigsawStructure structure, IrisPosition position, RNG rng) {
public PlannedStructure(IrisJigsawStructure structure, IrisPosition position, RNG rng) {
terminating = false;
verbose = true;
this.pieces = new KList<>();
@@ -103,8 +103,8 @@ public class PlannedStructure {
options.setMode(i.getPiece().getPlaceMode());
}
LoaderObject vo = i.getOgObject();
LoaderObject v = i.getObject();
IrisObject vo = i.getOgObject();
IrisObject v = i.getObject();
int sx = (v.getW() / 2);
int sz = (v.getD() / 2);
int xx = i.getPosition().getX() + sx;
@@ -176,7 +176,7 @@ public class PlannedStructure {
break;
}
IrisPosition p = i.getWorldPosition(j).add(new IrisPosition(j.getDirection().toVector().multiply(2)));
LoaderEntity e = getData().getEntityLoader().load(j.getSpawnEntity());
IrisEntity e = getData().getEntityLoader().load(j.getSpawnEntity());
if (a != null) {
Entity entity = e.spawn(a.getCompound().getEngineForHeight(p.getY()), new Location(world, p.getX() + 0.5, p.getY(), p.getZ() + 0.5), rng);
@@ -213,7 +213,7 @@ public class PlannedStructure {
}
private boolean generateConnectorOutwards(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector) {
for (LoaderJigsawPiece i : getShuffledPiecesFor(pieceConnector)) {
for (IrisJigsawPiece i : getShuffledPiecesFor(pieceConnector)) {
if (generateRotatedPiece(piece, pieceConnector, i)) {
return true;
}
@@ -222,7 +222,7 @@ public class PlannedStructure {
return false;
}
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, LoaderJigsawPiece idea) {
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, IrisJigsawPiece idea) {
if (!piece.getPiece().getPlacementOptions().getRotation().isEnabled()) {
if (generateRotatedPiece(piece, pieceConnector, idea, 0, 0, 0)) {
return true;
@@ -256,7 +256,7 @@ public class PlannedStructure {
return false;
}
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, LoaderJigsawPiece idea, IrisObjectRotation rotation) {
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, IrisJigsawPiece idea, IrisObjectRotation rotation) {
if (!idea.getPlacementOptions().getRotation().isEnabled())
rotation = piece.getRotation(); //Inherit parent rotation
@@ -271,7 +271,7 @@ public class PlannedStructure {
return false;
}
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, LoaderJigsawPiece idea, int x, int y, int z) {
private boolean generateRotatedPiece(PlannedPiece piece, IrisJigsawPieceConnector pieceConnector, IrisJigsawPiece idea, int x, int y, int z) {
return generateRotatedPiece(piece, pieceConnector, idea, IrisObjectRotation.of(x, y, z));
}
@@ -306,12 +306,12 @@ public class PlannedStructure {
return true;
}
private KList<LoaderJigsawPiece> getShuffledPiecesFor(IrisJigsawPieceConnector c) {
KList<LoaderJigsawPiece> p = new KList<>();
private KList<IrisJigsawPiece> getShuffledPiecesFor(IrisJigsawPieceConnector c) {
KList<IrisJigsawPiece> p = new KList<>();
for (String i : c.getPools().shuffleCopy(rng)) {
for (String j : getData().getJigsawPoolLoader().load(i).getPieces().shuffleCopy(rng)) {
LoaderJigsawPiece pi = getData().getJigsawPieceLoader().load(j);
IrisJigsawPiece pi = getData().getJigsawPieceLoader().load(j);
if (pi == null || (terminating && !pi.isTerminal())) {
continue;
@@ -382,7 +382,7 @@ public class PlannedStructure {
return false;
}
public LoaderObject rotated(LoaderJigsawPiece piece, IrisObjectRotation rotation) {
public IrisObject rotated(IrisJigsawPiece piece, IrisObjectRotation rotation) {
String key = piece.getObject() + "-" + rotation.hashCode();
return objectRotationCache.compute(key, (k, v) -> {

6
src/main/java/com/volmit/iris/engine/modifier/IrisCaveModifier.java
View File

@@ -18,12 +18,12 @@
package com.volmit.iris.engine.modifier;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedModifier;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.util.noise.FastNoiseDouble;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.carve.IrisCaveLayer;
import com.volmit.iris.engine.object.common.CaveResult;
import com.volmit.iris.util.parallel.BurstExecutor;
@@ -77,7 +77,7 @@ public class IrisCaveModifier extends EngineAssignedModifier<BlockData> {
KList<CaveResult> caves = genCaves(x + finalI, z + j, finalI, j, a);
int he = (int) Math.round(getComplex().getHeightStream().get(x + finalI, z + j));
if (caves != null && caves.isNotEmpty()) {
LoaderBiome cave = getComplex().getCaveBiomeStream().get(x + finalI, z + j);
IrisBiome cave = getComplex().getCaveBiomeStream().get(x + finalI, z + j);
if (cave == null) {
continue;

2
src/main/java/com/volmit/iris/engine/modifier/IrisCaveModifier2.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.modifier;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedModifier;
import com.volmit.iris.util.hunk.Hunk;

12
src/main/java/com/volmit/iris/engine/modifier/IrisDepositModifier.java
View File

@@ -21,10 +21,10 @@ package com.volmit.iris.engine.modifier;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedModifier;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.deposits.IrisDepositGenerator;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.util.data.HeightMap;
import com.volmit.iris.util.math.RNG;
import com.volmit.iris.util.scheduling.PrecisionStopwatch;
@@ -48,8 +48,8 @@ public class IrisDepositModifier extends EngineAssignedModifier<BlockData> {
public void generateDeposits(RNG rx, Hunk<BlockData> terrain, int x, int z) {
RNG ro = rx.nextParallelRNG(x * x).nextParallelRNG(z * z);
LoaderRegion region = getComplex().getRegionStream().get((x * 16) + 7, (z * 16) + 7);
LoaderBiome biome = getComplex().getTrueBiomeStream().get((x * 16) + 7, (z * 16) + 7);
IrisRegion region = getComplex().getRegionStream().get((x * 16) + 7, (z * 16) + 7);
IrisBiome biome = getComplex().getTrueBiomeStream().get((x * 16) + 7, (z * 16) + 7);
for (IrisDepositGenerator k : getDimension().getDeposits()) {
generate(k, terrain, ro, x, z, false);
@@ -74,7 +74,7 @@ public class IrisDepositModifier extends EngineAssignedModifier<BlockData> {
public void generate(IrisDepositGenerator k, Hunk<BlockData> data, RNG rng, int cx, int cz, boolean safe, HeightMap he) {
for (int l = 0; l < rng.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
LoaderObject clump = k.getClump(rng, getData());
IrisObject clump = k.getClump(rng, getData());
int af = (int) Math.ceil(clump.getW() / 2D);
int bf = (int) Math.floor(16D - (clump.getW() / 2D));

8
src/main/java/com/volmit/iris/engine/modifier/IrisPostModifier.java
View File

@@ -19,11 +19,11 @@
package com.volmit.iris.engine.modifier;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedModifier;
import com.volmit.iris.util.hunk.Hunk;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.common.CaveResult;
import com.volmit.iris.util.math.RNG;
import com.volmit.iris.util.scheduling.PrecisionStopwatch;
@@ -136,7 +136,7 @@ public class IrisPostModifier extends EngineAssignedModifier<BlockData> {
}
// Wall Patcher
LoaderBiome biome = getComplex().getTrueBiomeStream().get(x, z);
IrisBiome biome = getComplex().getTrueBiomeStream().get(x, z);
if (getDimension().isPostProcessingWalls()) {
if (!biome.getWall().getPalette().isEmpty()) {
@@ -231,7 +231,7 @@ public class IrisPostModifier extends EngineAssignedModifier<BlockData> {
}
if (getDimension().isPostProcessCaves()) {
LoaderBiome cave = getComplex().getCaveBiomeStream().get(x, z);
IrisBiome cave = getComplex().getCaveBiomeStream().get(x, z);
if (cave != null) {
for (CaveResult i : ((IrisCaveModifier) getFramework().getCaveModifier()).genCaves(x, z, 0, 0, null)) {

2
src/main/java/com/volmit/iris/engine/modifier/IrisRavineModifier.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.modifier;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineAssignedModifier;
import com.volmit.iris.util.hunk.Hunk;

4
src/main/java/com/volmit/iris/engine/object/annotations/RegistryListResource.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.object.annotations;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@@ -29,5 +29,5 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
@Retention(RUNTIME)
@Target({PARAMETER, TYPE, FIELD})
public @interface RegistryListResource {
Class<? extends LoaderRegistrant> value();
Class<? extends IrisRegistrant> value();
}

36
src/main/java/com/volmit/iris/engine/object/biome/LoaderBiome.java → src/main/java/com/volmit/iris/engine/object/biome/IrisBiome.java
View File

@@ -21,11 +21,11 @@ package com.volmit.iris.engine.object.biome;
import com.volmit.iris.Iris;
import com.volmit.iris.core.gui.components.RenderType;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.IrisComplex;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.IrisAccess;
import com.volmit.iris.engine.object.block.IrisBlockDrops;
@@ -38,9 +38,9 @@ import com.volmit.iris.engine.object.meta.IrisEffect;
import com.volmit.iris.engine.object.noise.IrisGeneratorStyle;
import com.volmit.iris.engine.object.noise.IrisSlopeClip;
import com.volmit.iris.engine.object.noise.NoiseStyle;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.util.noise.CNG;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.engine.object.common.IRare;
@@ -68,7 +68,7 @@ import java.awt.*;
@Desc("Represents a biome in iris. Biomes are placed inside of regions and hold objects.\nA biome consists of layers (block palletes), decorations, objects & generators.")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderBiome extends LoaderRegistrant implements IRare {
public class IrisBiome extends IrisRegistrant implements IRare {
@MinNumber(2)
@Required
@Desc("This is the human readable name for this biome. This can and should be different than the file name. This is not used for loading biomes in other objects.")
@@ -80,7 +80,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
@Desc("Spawn Entities in this area over time. Iris will continually replenish these mobs just like vanilla does.")
@ArrayType(min = 1, type = String.class)
@RegistryListResource(LoaderSpawner.class)
@RegistryListResource(IrisSpawner.class)
private KList<String> entitySpawners = new KList<>();
@Desc("Add random chances for terrain features")
@@ -146,7 +146,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
@Desc("If this biome has children biomes, and the gen layer chooses one of this biomes children, How will it be shaped?")
private IrisGeneratorStyle childStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@ArrayType(min = 1, type = String.class)
@Desc("List any biome names (file names without.json) here as children. Portions of this biome can sometimes morph into their children. Iris supports cyclic relationships such as A > B > A > B. Iris will stop checking 9 biomes down the tree.")
private KList<String> children = new KList<>();
@@ -155,7 +155,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
@Desc("Jigsaw structures")
private KList<IrisJigsawStructurePlacement> jigsawStructures = new KList<>();
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Desc("The carving biome. If specified the biome will be used when under a carving instead of this current biome.")
private String carvingBiome = "";
@@ -207,8 +207,8 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
private final transient AtomicCache<CNG> biomeGenerator = new AtomicCache<>();
private final transient AtomicCache<Integer> maxHeight = new AtomicCache<>();
private final transient AtomicCache<Integer> maxWithObjectHeight = new AtomicCache<>();
private final transient AtomicCache<LoaderBiome> realCarveBiome = new AtomicCache<>();
private final transient AtomicCache<KList<LoaderBiome>> realChildren = new AtomicCache<>();
private final transient AtomicCache<IrisBiome> realCarveBiome = new AtomicCache<>();
private final transient AtomicCache<KList<IrisBiome>> realChildren = new AtomicCache<>();
private final transient AtomicCache<KList<CNG>> layerHeightGenerators = new AtomicCache<>();
private final transient AtomicCache<KList<CNG>> layerSeaHeightGenerators = new AtomicCache<>();
@@ -263,10 +263,10 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
}).get(loadKey);
}
public LoaderBiome getRealCarvingBiome(IrisData data) {
public IrisBiome getRealCarvingBiome(IrisData data) {
return realCarveBiome.aquire(() ->
{
LoaderBiome biome = data.getBiomeLoader().load(getCarvingBiome());
IrisBiome biome = data.getBiomeLoader().load(getCarvingBiome());
if (biome == null) {
biome = this;
@@ -445,7 +445,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
int gg = 0;
for (IrisObjectPlacement i : getObjects()) {
for (LoaderObject j : data.getObjectLoader().loadAll(i.getPlace())) {
for (IrisObject j : data.getObjectLoader().loadAll(i.getPlace())) {
gg = Math.max(gg, j.getH());
}
}
@@ -454,7 +454,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
});
}
public LoaderBiome infer(InferredType t, InferredType type) {
public IrisBiome infer(InferredType t, InferredType type) {
setInferredType(t.equals(InferredType.DEFER) ? type : t);
return this;
}
@@ -582,10 +582,10 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
return customDerivitives.get(getBiomeGenerator(rng).fit(0, customDerivitives.size() - 1, x, y, z));
}
public KList<LoaderBiome> getRealChildren(DataProvider g) {
public KList<IrisBiome> getRealChildren(DataProvider g) {
return realChildren.aquire(() ->
{
KList<LoaderBiome> realChildren = new KList<>();
KList<IrisBiome> realChildren = new KList<>();
for (String i : getChildren()) {
realChildren.add(g.getData().getBiomeLoader().load(i));
@@ -602,7 +602,7 @@ public class LoaderBiome extends LoaderRegistrant implements IRare {
if (limit > 0) {
for (String i : getChildren()) {
LoaderBiome b = g.getData().getBiomeLoader().load(i);
IrisBiome b = g.getData().getBiomeLoader().load(i);
m.addAll(b.getAllChildren(g, limit));
}
}

14
src/main/java/com/volmit/iris/engine/object/biome/IrisBiomeGeneratorLink.java
View File

@@ -19,10 +19,10 @@
package com.volmit.iris.engine.object.biome;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.util.interpolation.IrisInterpolation;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.engine.object.noise.LoaderGenerator;
import com.volmit.iris.engine.object.noise.IrisGenerator;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@@ -35,7 +35,7 @@ import lombok.experimental.Accessors;
@Data
public class IrisBiomeGeneratorLink {
@RegistryListResource(LoaderGenerator.class)
@RegistryListResource(IrisGenerator.class)
@Desc("The generator id")
private String generator = "default";
@@ -53,15 +53,15 @@ public class IrisBiomeGeneratorLink {
@Desc("The max block value (value + fluidHeight)")
private int max = 0;
private final transient AtomicCache<LoaderGenerator> gen = new AtomicCache<>();
private final transient AtomicCache<IrisGenerator> gen = new AtomicCache<>();
public LoaderGenerator getCachedGenerator(DataProvider g) {
public IrisGenerator getCachedGenerator(DataProvider g) {
return gen.aquire(() ->
{
LoaderGenerator gen = g.getData().getGeneratorLoader().load(getGenerator());
IrisGenerator gen = g.getData().getGeneratorLoader().load(getGenerator());
if (gen == null) {
gen = new LoaderGenerator();
gen = new IrisGenerator();
}
return gen;

10
src/main/java/com/volmit/iris/engine/object/biome/IrisBiomeMutation.java
View File

@@ -19,9 +19,9 @@
package com.volmit.iris.engine.object.biome;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KSet;
@@ -36,13 +36,13 @@ import lombok.experimental.Accessors;
@Desc("A biome mutation if a condition is met")
@Data
public class IrisBiomeMutation {
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Required
@ArrayType(min = 1, type = String.class)
@Desc("One of The following biomes or regions must show up")
private KList<String> sideA = new KList<>();
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Required
@ArrayType(min = 1, type = String.class)
@Desc("One of The following biomes or regions must show up")
@@ -60,7 +60,7 @@ public class IrisBiomeMutation {
@Desc("How many tries per chunk to check for this mutation")
private int checks = 2;
@RegistryListResource(LoaderObject.class)
@RegistryListResource(IrisObject.class)
@ArrayType(min = 1, type = IrisObjectPlacement.class)
@Desc("Objects define what schematics (iob files) iris will place in this biome mutation")
private KList<IrisObjectPlacement> objects = new KList<>();

12
src/main/java/com/volmit/iris/engine/object/biome/IrisBiomePaletteLayer.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.object.biome;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.noise.IrisGeneratorStyle;
import com.volmit.iris.engine.object.noise.IrisSlopeClip;
import com.volmit.iris.engine.object.noise.NoiseStyle;
@@ -66,9 +66,9 @@ public class IrisBiomePaletteLayer {
private double zoom = 5;
@Required
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The palette of blocks to be used in this layer")
private KList<LoaderBlockData> palette = new KList<LoaderBlockData>().qadd(new LoaderBlockData("GRASS_BLOCK"));
private KList<IrisBlockData> palette = new KList<IrisBlockData>().qadd(new IrisBlockData("GRASS_BLOCK"));
private final transient AtomicCache<KList<BlockData>> blockData = new AtomicCache<>();
private final transient AtomicCache<CNG> layerGenerator = new AtomicCache<>();
@@ -98,8 +98,8 @@ public class IrisBiomePaletteLayer {
});
}
public KList<LoaderBlockData> add(String b) {
palette.add(new LoaderBlockData(b));
public KList<IrisBlockData> add(String b) {
palette.add(new IrisBlockData(b));
return palette;
}
@@ -108,7 +108,7 @@ public class IrisBiomePaletteLayer {
return blockData.aquire(() ->
{
KList<BlockData> blockData = new KList<>();
for (LoaderBlockData ix : palette) {
for (IrisBlockData ix : palette) {
BlockData bx = ix.getBlockData(data);
if (bx != null) {
for (int i = 0; i < ix.getWeight(); i++) {

16
src/main/java/com/volmit/iris/engine/object/block/LoaderBlockData.java → src/main/java/com/volmit/iris/engine/object/block/IrisBlockData.java
View File

@@ -21,8 +21,8 @@ package com.volmit.iris.engine.object.block;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.util.data.B;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.collection.KMap;
@@ -42,7 +42,7 @@ import java.util.Map;
@Desc("Represents Block Data")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderBlockData extends LoaderRegistrant {
public class IrisBlockData extends IrisRegistrant {
@RegistryListBlockType
@Required
@Desc("The block to use")
@@ -60,7 +60,7 @@ public class LoaderBlockData extends LoaderRegistrant {
private int weight = 1;
@Desc("If the block cannot be created on this version, Iris will attempt to use this backup block data instead.")
private LoaderBlockData backup = null;
private IrisBlockData backup = null;
@Desc("Optional properties for this block data such as 'waterlogged': true")
private KMap<String, Object> data = new KMap<>();
@@ -68,7 +68,7 @@ public class LoaderBlockData extends LoaderRegistrant {
private final transient AtomicCache<BlockData> blockdata = new AtomicCache<>();
private final transient AtomicCache<String> realProperties = new AtomicCache<>();
public LoaderBlockData(String b) {
public IrisBlockData(String b) {
this.block = b;
}
@@ -95,7 +95,7 @@ public class LoaderBlockData extends LoaderRegistrant {
{
BlockData b = null;
LoaderBlockData customData = data.getBlockLoader().load(getBlock(), false);
IrisBlockData customData = data.getBlockLoader().load(getBlock(), false);
if (customData != null) {
b = customData.getBlockData(data);
@@ -152,8 +152,8 @@ public class LoaderBlockData extends LoaderRegistrant {
});
}
public static LoaderBlockData from(String j) {
LoaderBlockData b = new LoaderBlockData();
public static IrisBlockData from(String j) {
IrisBlockData b = new IrisBlockData();
String m = j.toLowerCase().trim();
if (m.contains(":")) {

6
src/main/java/com/volmit/iris/engine/object/block/IrisBlockDrops.java
View File

@@ -40,9 +40,9 @@ import org.bukkit.inventory.ItemStack;
@Data
public class IrisBlockDrops {
@Required
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The blocks that drop loot")
private KList<LoaderBlockData> blocks = new KList<>();
private KList<IrisBlockData> blocks = new KList<>();
@Desc("If exact blocks is set to true, minecraft:barrel[axis=x] will only drop for that axis. When exact is false (default) any barrel will drop the defined drops.")
private boolean exactBlocks = false;
@@ -64,7 +64,7 @@ public class IrisBlockDrops {
{
KList<BlockData> b = new KList<>();
for (LoaderBlockData i : getBlocks()) {
for (IrisBlockData i : getBlocks()) {
BlockData dd = i.getBlockData(rdata);
if (dd != null) {

12
src/main/java/com/volmit/iris/engine/object/block/IrisMaterialPalette.java
View File

@@ -49,9 +49,9 @@ public class IrisMaterialPalette {
private double zoom = 5;
@Required
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The palette of blocks to be used in this layer")
private KList<LoaderBlockData> palette = new KList<LoaderBlockData>().qadd(new LoaderBlockData("STONE"));
private KList<IrisBlockData> palette = new KList<IrisBlockData>().qadd(new IrisBlockData("STONE"));
private final transient AtomicCache<KList<BlockData>> blockData = new AtomicCache<>();
private final transient AtomicCache<CNG> layerGenerator = new AtomicCache<>();
@@ -82,14 +82,14 @@ public class IrisMaterialPalette {
return this;
}
public KList<LoaderBlockData> add(String b) {
palette.add(new LoaderBlockData(b));
public KList<IrisBlockData> add(String b) {
palette.add(new IrisBlockData(b));
return palette;
}
public IrisMaterialPalette qadd(String b) {
palette.add(new LoaderBlockData(b));
palette.add(new IrisBlockData(b));
return this;
}
@@ -98,7 +98,7 @@ public class IrisMaterialPalette {
return blockData.aquire(() ->
{
KList<BlockData> blockData = new KList<>();
for (LoaderBlockData ix : palette) {
for (IrisBlockData ix : palette) {
BlockData bx = ix.getBlockData(rdata);
if (bx != null) {
for (int i = 0; i < ix.getWeight(); i++) {

6
src/main/java/com/volmit/iris/engine/object/carve/IrisCaveFluid.java
View File

@@ -20,8 +20,8 @@ package com.volmit.iris.engine.object.carve;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.MaxNumber;
import com.volmit.iris.engine.object.annotations.MinNumber;
@@ -49,7 +49,7 @@ public class IrisCaveFluid {
@Required
@Desc("The fluid type that should spawn here")
private LoaderBlockData fluidType = new LoaderBlockData("CAVE_AIR");
private IrisBlockData fluidType = new IrisBlockData("CAVE_AIR");
private final transient AtomicCache<BlockData> fluidData = new AtomicCache<>();

2
src/main/java/com/volmit/iris/engine/object/compat/IrisCompat.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.object.compat;
import com.google.gson.Gson;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.io.IO;
import com.volmit.iris.util.json.JSONObject;

2
src/main/java/com/volmit/iris/engine/object/compat/IrisCompatabilityBlockFilter.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.object.compat;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.Required;
import lombok.AllArgsConstructor;

2
src/main/java/com/volmit/iris/engine/object/compat/IrisCompatabilityItemFilter.java
View File

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.object.compat;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.B;
import com.volmit.iris.util.data.B;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.Required;
import lombok.Data;

26
src/main/java/com/volmit/iris/engine/object/decoration/IrisDecorator.java
View File

@@ -21,8 +21,8 @@ package com.volmit.iris.engine.object.decoration;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.noise.IrisGeneratorStyle;
import com.volmit.iris.engine.object.noise.NoiseStyle;
import com.volmit.iris.util.noise.CNG;
@@ -82,13 +82,13 @@ public class IrisDecorator {
private double chance = 0.1;
@Required
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The palette of blocks to pick from when this decorator needs to place.")
private KList<LoaderBlockData> palette = new KList<LoaderBlockData>().qadd(new LoaderBlockData("grass"));
private KList<IrisBlockData> palette = new KList<IrisBlockData>().qadd(new IrisBlockData("grass"));
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The palette of blocks used at the very top of a 'stackMax' of higher than 1. For example, bamboo tops.")
private KList<LoaderBlockData> topPalette = new KList<>();
private KList<IrisBlockData> topPalette = new KList<>();
@DependsOn("topPalette")
@MinNumber(0.01)
@@ -126,12 +126,12 @@ public class IrisDecorator {
.scale(1D / variance.getZoom()));
}
public KList<LoaderBlockData> add(String b) {
palette.add(new LoaderBlockData(b));
public KList<IrisBlockData> add(String b) {
palette.add(new IrisBlockData(b));
return palette;
}
public BlockData getBlockData(LoaderBiome b, RNG rng, double x, double z, IrisData data) {
public BlockData getBlockData(IrisBiome b, RNG rng, double x, double z, IrisData data) {
if (getBlockData(data).isEmpty()) {
Iris.warn("Empty Block Data for " + b.getName());
return null;
@@ -151,7 +151,7 @@ public class IrisDecorator {
return null;
}
public BlockData getBlockData100(LoaderBiome b, RNG rng, double x, double y, double z, IrisData data) {
public BlockData getBlockData100(IrisBiome b, RNG rng, double x, double y, double z, IrisData data) {
if (getBlockData(data).isEmpty()) {
Iris.warn("Empty Block Data for " + b.getName());
return null;
@@ -174,7 +174,7 @@ public class IrisDecorator {
return getVarianceGenerator(rng, data).fit(getBlockData(data), z, y, x).clone(); //X and Z must be switched
}
public BlockData getBlockDataForTop(LoaderBiome b, RNG rng, double x, double y, double z, IrisData data) {
public BlockData getBlockDataForTop(IrisBiome b, RNG rng, double x, double y, double z, IrisData data) {
if (getBlockDataTops(data).isEmpty()) {
return getBlockData100(b, rng, x, y, z, data);
}
@@ -197,7 +197,7 @@ public class IrisDecorator {
return blockData.aquire(() ->
{
KList<BlockData> blockData = new KList<>();
for (LoaderBlockData i : palette) {
for (IrisBlockData i : palette) {
BlockData bx = i.getBlockData(data);
if (bx != null) {
for (int n = 0; n < i.getWeight(); n++) {
@@ -214,7 +214,7 @@ public class IrisDecorator {
return blockDataTops.aquire(() ->
{
KList<BlockData> blockDataTops = new KList<>();
for (LoaderBlockData i : topPalette) {
for (IrisBlockData i : topPalette) {
BlockData bx = i.getBlockData(data);
if (bx != null) {
for (int n = 0; n < i.getWeight(); n++) {

22
src/main/java/com/volmit/iris/engine/object/deposits/IrisDepositGenerator.java
View File

@@ -21,8 +21,8 @@ package com.volmit.iris.engine.object.deposits;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.engine.object.block.LoaderBlockData;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.block.IrisBlockData;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.util.collection.KList;
import com.volmit.iris.util.math.RNG;
import lombok.AllArgsConstructor;
@@ -75,23 +75,23 @@ public class IrisDepositGenerator {
private int minPerChunk = 1;
@Required
@ArrayType(min = 1, type = LoaderBlockData.class)
@ArrayType(min = 1, type = IrisBlockData.class)
@Desc("The palette of blocks to be used in this deposit generator")
private KList<LoaderBlockData> palette = new KList<>();
private KList<IrisBlockData> palette = new KList<>();
@MinNumber(1)
@MaxNumber(64)
@Desc("Ore varience is how many different objects clumps iris will create")
private int varience = 3;
private final transient AtomicCache<KList<LoaderObject>> objects = new AtomicCache<>();
private final transient AtomicCache<KList<IrisObject>> objects = new AtomicCache<>();
private final transient AtomicCache<KList<BlockData>> blockData = new AtomicCache<>();
public LoaderObject getClump(RNG rng, IrisData rdata) {
KList<LoaderObject> objects = this.objects.aquire(() ->
public IrisObject getClump(RNG rng, IrisData rdata) {
KList<IrisObject> objects = this.objects.aquire(() ->
{
RNG rngv = rng.nextParallelRNG(3957778);
KList<LoaderObject> objectsf = new KList<>();
KList<IrisObject> objectsf = new KList<>();
for (int i = 0; i < varience; i++) {
objectsf.add(generateClumpObject(rngv.nextParallelRNG(2349 * i + 3598), rdata));
@@ -106,11 +106,11 @@ public class IrisDepositGenerator {
return Math.min(11, (int) Math.round(Math.pow(maxSize, 1D / 3D)));
}
private LoaderObject generateClumpObject(RNG rngv, IrisData rdata) {
private IrisObject generateClumpObject(RNG rngv, IrisData rdata) {
int s = rngv.i(minSize, maxSize);
int dim = Math.min(11, (int) Math.round(Math.pow(maxSize, 1D / 3D)));
int w = dim / 2;
LoaderObject o = new LoaderObject(dim, dim, dim);
IrisObject o = new IrisObject(dim, dim, dim);
if (s == 1) {
o.getBlocks().put(o.getCenter(), nextBlock(rngv, rdata));
@@ -135,7 +135,7 @@ public class IrisDepositGenerator {
{
KList<BlockData> blockData = new KList<>();
for (LoaderBlockData ix : palette) {
for (IrisBlockData ix : palette) {
BlockData bx = ix.getBlockData(rdata);
if (bx != null) {

48
src/main/java/com/volmit/iris/engine/object/dimensional/LoaderDimension.java → src/main/java/com/volmit/iris/engine/object/dimensional/IrisDimension.java
View File

@@ -20,11 +20,11 @@ package com.volmit.iris.engine.object.dimensional;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.data.DataProvider;
import com.volmit.iris.util.data.DataProvider;
import com.volmit.iris.engine.object.biome.InferredType;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.biome.IrisBiomeCustom;
import com.volmit.iris.engine.object.biome.IrisBiomeMutation;
import com.volmit.iris.engine.object.block.IrisBlockDrops;
@@ -36,15 +36,15 @@ import com.volmit.iris.engine.object.carve.IrisCaverns;
import com.volmit.iris.engine.object.deposits.IrisDepositGenerator;
import com.volmit.iris.engine.object.feature.IrisFeaturePositional;
import com.volmit.iris.engine.object.feature.IrisFeaturePotential;
import com.volmit.iris.engine.object.jigsaw.LoaderJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructure;
import com.volmit.iris.engine.object.jigsaw.IrisJigsawStructurePlacement;
import com.volmit.iris.engine.object.loot.IrisLootReference;
import com.volmit.iris.engine.object.noise.IrisGeneratorStyle;
import com.volmit.iris.engine.object.noise.IrisShapedGeneratorStyle;
import com.volmit.iris.engine.object.noise.NoiseStyle;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.engine.object.regional.LoaderRegion;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.regional.IrisRegion;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.engine.object.trees.IrisTreeSettings;
import com.volmit.iris.util.noise.CNG;
import com.volmit.iris.engine.object.annotations.*;
@@ -71,7 +71,7 @@ import java.io.IOException;
@Desc("Represents a dimension")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderDimension extends LoaderRegistrant {
public class IrisDimension extends IrisRegistrant {
public static final BlockData STONE = Material.STONE.createBlockData();
public static final BlockData WATER = Material.WATER.createBlockData();
@@ -85,9 +85,9 @@ public class LoaderDimension extends LoaderRegistrant {
private KList<IrisDimensionIndex> dimensionalComposite = new KList<>();
@Desc("Create an inverted dimension in the sky (like the nether)")
private LoaderDimension sky = null;
private IrisDimension sky = null;
@RegistryListResource(LoaderJigsawStructure.class)
@RegistryListResource(IrisJigsawStructure.class)
@Desc("If defined, Iris will place the given jigsaw structure where minecraft should place the overworld stronghold.")
private String stronghold;
@@ -114,7 +114,7 @@ public class LoaderDimension extends LoaderRegistrant {
@Desc("Spawn Entities in this dimension over time. Iris will continually replenish these mobs just like vanilla does.")
@ArrayType(min = 1, type = String.class)
@RegistryListResource(LoaderSpawner.class)
@RegistryListResource(IrisSpawner.class)
private KList<String> entitySpawners = new KList<>();
@Desc("Add specific features in exact positions")
@@ -218,7 +218,7 @@ public class LoaderDimension extends LoaderRegistrant {
@Desc("The world environment")
private Environment environment = Environment.NORMAL;
@RegistryListResource(LoaderRegion.class)
@RegistryListResource(IrisRegion.class)
@Required
@ArrayType(min = 1, type = String.class)
@Desc("Define all of the regions to include in this dimension. Dimensions -> Regions -> Biomes -> Objects etc")
@@ -234,11 +234,11 @@ public class LoaderDimension extends LoaderRegistrant {
@Desc("The fluid height for this dimension")
private int fluidHeight = 63;
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Desc("Keep this either undefined or empty. Setting any biome name into this will force iris to only generate the specified biome. Great for testing.")
private String focus = "";
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Desc("Keep this either undefined or empty. Setting any region name into this will force iris to only generate the specified region. Great for testing.")
private String focusRegion = "";
@@ -409,8 +409,8 @@ public class LoaderDimension extends LoaderRegistrant {
return cosr.aquire(() -> Math.cos(getDimensionAngle()));
}
public KList<LoaderRegion> getAllRegions(DataProvider g) {
KList<LoaderRegion> r = new KList<>();
public KList<IrisRegion> getAllRegions(DataProvider g) {
KList<IrisRegion> r = new KList<>();
for (String i : getRegions()) {
r.add(g.getData().getRegionLoader().load(i));
@@ -419,8 +419,8 @@ public class LoaderDimension extends LoaderRegistrant {
return r;
}
public KList<LoaderRegion> getAllAnyRegions() {
KList<LoaderRegion> r = new KList<>();
public KList<IrisRegion> getAllAnyRegions() {
KList<IrisRegion> r = new KList<>();
for (String i : getRegions()) {
r.add(IrisData.loadAnyRegion(i));
@@ -429,14 +429,14 @@ public class LoaderDimension extends LoaderRegistrant {
return r;
}
public KList<LoaderBiome> getAllBiomes(DataProvider g) {
public KList<IrisBiome> getAllBiomes(DataProvider g) {
return g.getData().getBiomeLoader().loadAll(g.getData().getBiomeLoader().getPossibleKeys());
}
public KList<LoaderBiome> getAllAnyBiomes() {
KList<LoaderBiome> r = new KList<>();
public KList<IrisBiome> getAllAnyBiomes() {
KList<IrisBiome> r = new KList<>();
for (LoaderRegion i : getAllAnyRegions()) {
for (IrisRegion i : getAllAnyRegions()) {
if (i == null) {
continue;
}
@@ -474,7 +474,7 @@ public class LoaderDimension extends LoaderRegistrant {
IO.delete(new File(datapacks, "iris/data/" + getLoadKey()));
for (LoaderBiome i : getAllBiomes(data)) {
for (IrisBiome i : getAllBiomes(data)) {
if (i.isCustom()) {
write = true;
@@ -524,7 +524,7 @@ public class LoaderDimension extends LoaderRegistrant {
return true;
}
for (LoaderRegion i : getAllRegions(data)) {
for (IrisRegion i : getAllRegions(data)) {
if (i.getFeatures().isNotEmpty()) {
return true;
}
@@ -535,7 +535,7 @@ public class LoaderDimension extends LoaderRegistrant {
}
}
for (LoaderBiome j : i.getAllBiomes(data)) {
for (IrisBiome j : i.getAllBiomes(data)) {
if (j.getFeatures().isNotEmpty()) {
return true;
}

2
src/main/java/com/volmit/iris/engine/object/dimensional/IrisDimensionIndex.java
View File

@@ -47,7 +47,7 @@ public class IrisDimensionIndex {
private boolean primary = false;
@Required
@RegistryListResource(LoaderDimension.class)
@RegistryListResource(IrisDimension.class)
@MinNumber(1)
@Desc("Name of dimension")
private String dimension = "";

18
src/main/java/com/volmit/iris/engine/object/entity/LoaderEntity.java → src/main/java/com/volmit/iris/engine/object/entity/IrisEntity.java
View File

@@ -19,14 +19,14 @@
package com.volmit.iris.engine.object.entity;
import com.volmit.iris.Iris;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.object.annotations.ArrayType;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.Required;
import com.volmit.iris.engine.object.loot.IrisLoot;
import com.volmit.iris.engine.object.loot.IrisLootReference;
import com.volmit.iris.engine.object.loot.LoaderLootTable;
import com.volmit.iris.engine.object.loot.IrisLootTable;
import com.volmit.iris.engine.object.meta.InventorySlotType;
import com.volmit.iris.engine.object.meta.IrisAttributeModifier;
import com.volmit.iris.engine.object.meta.IrisEffect;
@@ -65,7 +65,7 @@ import java.util.concurrent.atomic.AtomicReference;
@Desc("Represents an iris entity.")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderEntity extends LoaderRegistrant {
public class IrisEntity extends IrisRegistrant {
@Required
@Desc("The type of entity to spawn. To spawn a mythic mob, set this type to unknown and define mythic type.")
private EntityType type = EntityType.UNKNOWN;
@@ -119,8 +119,8 @@ public class LoaderEntity extends LoaderRegistrant {
private IrisLoot offHand = null;
@Desc("Make other entities ride this entity")
@ArrayType(min = 1, type = LoaderEntity.class)
private KList<LoaderEntity> passengers = new KList<>();
@ArrayType(min = 1, type = IrisEntity.class)
private KList<IrisEntity> passengers = new KList<>();
@Desc("Attribute modifiers for this entity")
@ArrayType(min = 1, type = IrisAttributeModifier.class)
@@ -130,7 +130,7 @@ public class LoaderEntity extends LoaderRegistrant {
private IrisLootReference loot = new IrisLootReference();
@Desc("If specified, this entity will be leashed by this entity. I.e. THIS ENTITY Leashed by SPECIFIED. This has no effect on EnderDragons, Withers, Players, or Bats.Non-living entities excluding leashes will not persist as leashholders.")
private LoaderEntity leashHolder = null;
private IrisEntity leashHolder = null;
@Desc("If specified, this entity will spawn with an effect")
private IrisEffect spawnEffect = null;
@@ -171,7 +171,7 @@ public class LoaderEntity extends LoaderRegistrant {
e.setPersistent(isKeepEntity());
int gg = 0;
for (LoaderEntity i : passengers) {
for (IrisEntity i : passengers) {
Entity passenger = i.spawn(gen, at, rng.nextParallelRNG(234858 + gg++));
if (!Bukkit.isPrimaryThread()) {
J.s(() -> e.addPassenger(passenger));
@@ -193,7 +193,7 @@ public class LoaderEntity extends LoaderRegistrant {
l.setLootTable(new LootTable() {
@Override
public NamespacedKey getKey() {
return new NamespacedKey(Iris.instance, "loot-" + LoaderEntity.this.hashCode());
return new NamespacedKey(Iris.instance, "loot-" + IrisEntity.this.hashCode());
}
@Override
@@ -201,7 +201,7 @@ public class LoaderEntity extends LoaderRegistrant {
KList<ItemStack> items = new KList<>();
for (String fi : getLoot().getTables()) {
LoaderLootTable i = gen.getData().getLootLoader().load(fi);
IrisLootTable i = gen.getData().getLootLoader().load(fi);
items.addAll(i.getLoot(gen.isStudio(), false, rng.nextParallelRNG(345911), InventorySlotType.STORAGE, at.getBlockX(), at.getBlockY(), at.getBlockZ(), 8, 4));
}

16
src/main/java/com/volmit/iris/engine/object/entity/IrisEntitySpawn.java
View File

@@ -24,8 +24,8 @@ import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.framework.Engine;
import com.volmit.iris.engine.framework.EngineFramework;
import com.volmit.iris.engine.modifier.IrisCaveModifier;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.MinNumber;
import com.volmit.iris.engine.object.annotations.RegistryListResource;
@@ -49,7 +49,7 @@ import org.bukkit.entity.Entity;
@Desc("Represents an entity spawn during initial chunk generation")
@Data
public class IrisEntitySpawn implements IRare {
@RegistryListResource(LoaderEntity.class)
@RegistryListResource(IrisEntity.class)
@Required
@Desc("The entity")
private String entity = "";
@@ -69,9 +69,9 @@ public class IrisEntitySpawn implements IRare {
@Desc("The max of this entity to spawn")
private int maxSpawns = 1;
private transient LoaderSpawner referenceSpawner;
private transient IrisSpawner referenceSpawner;
private final transient AtomicCache<RNG> rng = new AtomicCache<>();
private final transient AtomicCache<LoaderEntity> ent = new AtomicCache<>();
private final transient AtomicCache<IrisEntity> ent = new AtomicCache<>();
public int spawn(Engine gen, Chunk c, RNG rng) {
int spawns = minSpawns == maxSpawns ? minSpawns : rng.i(Math.min(minSpawns, maxSpawns), Math.max(minSpawns, maxSpawns));
@@ -88,7 +88,7 @@ public class IrisEntitySpawn implements IRare {
case CAVE -> {
IrisComplex comp = gen.getFramework().getComplex();
EngineFramework frame = gen.getFramework();
LoaderBiome cave = comp.getCaveBiomeStream().get(x, z);
IrisBiome cave = comp.getCaveBiomeStream().get(x, z);
KList<Location> r = new KList<>();
if (cave != null) {
for (CaveResult i : ((IrisCaveModifier) frame.getCaveModifier()).genCaves(x, z)) {
@@ -116,7 +116,7 @@ public class IrisEntitySpawn implements IRare {
return s;
}
public LoaderEntity getRealEntity(Engine g) {
public IrisEntity getRealEntity(Engine g) {
return ent.aquire(() -> g.getData().getEntityLoader().load(getEntity()));
}
@@ -134,7 +134,7 @@ public class IrisEntitySpawn implements IRare {
private Entity spawn100(Engine g, Location at) {
try {
LoaderEntity irisEntity = getRealEntity(g);
IrisEntity irisEntity = getRealEntity(g);
if (!irisEntity.getSurface().matches(at.clone().subtract(0, 1, 0).getBlock().getState())) return null; //Make sure it can spawn on the block

6
src/main/java/com/volmit/iris/engine/object/entity/IrisEntitySpawnOverride.java
View File

@@ -40,7 +40,7 @@ import org.bukkit.event.entity.EntitySpawnEvent;
@Desc("Represents an entity spawn")
@Data
public class IrisEntitySpawnOverride {
@RegistryListResource(LoaderEntity.class)
@RegistryListResource(IrisEntity.class)
@Required
@Desc("The entity")
private String entity = "";
@@ -57,7 +57,7 @@ public class IrisEntitySpawnOverride {
private int rarity = 1;
private final transient AtomicCache<RNG> rng = new AtomicCache<>();
private final transient AtomicCache<LoaderEntity> ent = new AtomicCache<>();
private final transient AtomicCache<IrisEntity> ent = new AtomicCache<>();
public Entity on(Engine g, Location at, EntityType t, EntitySpawnEvent ee) {
@@ -89,7 +89,7 @@ public class IrisEntitySpawnOverride {
return null;
}
public LoaderEntity getRealEntity(Engine g) {
public IrisEntity getRealEntity(Engine g) {
return ent.aquire(() -> g.getData().getEntityLoader().load(getEntity()));
}
}

8
src/main/java/com/volmit/iris/engine/object/feature/IrisFeature.java
View File

@@ -22,8 +22,8 @@ import com.google.gson.Gson;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.util.interpolation.InterpolationMethod;
import com.volmit.iris.util.interpolation.IrisInterpolation;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.spawners.LoaderSpawner;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.spawners.IrisSpawner;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.engine.object.noise.IrisGeneratorStyle;
import com.volmit.iris.util.collection.KList;
@@ -50,7 +50,7 @@ public class IrisFeature {
@Desc("The chance an object that should be place actually will place. Set to below 1 to affect objects in this zone")
private double objectChance = 1;
@RegistryListResource(LoaderBiome.class)
@RegistryListResource(IrisBiome.class)
@Desc("Apply a custom biome here")
private String customBiome = null;
@@ -85,7 +85,7 @@ public class IrisFeature {
@Desc("Fracture the radius ring with additional noise")
private IrisGeneratorStyle fractureRadius = null;
@RegistryListResource(LoaderSpawner.class)
@RegistryListResource(IrisSpawner.class)
@ArrayType(min = 1, type = String.class)
@Desc("Within this noise feature, use the following spawners")
private KList<String> entitySpawners = new KList<>();

6
src/main/java/com/volmit/iris/engine/object/feature/IrisFeaturePositional.java
View File

@@ -22,7 +22,7 @@ import com.google.gson.Gson;
import com.volmit.iris.core.project.loader.IrisData;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.util.interpolation.IrisInterpolation;
import com.volmit.iris.engine.object.biome.LoaderBiome;
import com.volmit.iris.engine.object.biome.IrisBiome;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.Required;
import com.volmit.iris.util.documentation.BlockCoordinates;
@@ -125,10 +125,10 @@ public class IrisFeaturePositional {
return M.lerp(1, getFeature().getObjectChance(), getStrength(x, z, rng, data));
}
public LoaderBiome filter(double x, double z, LoaderBiome biome, RNG rng) {
public IrisBiome filter(double x, double z, IrisBiome biome, RNG rng) {
if (getFeature().getCustomBiome() != null) {
if (getStrength(x, z, rng, biome.getLoader()) >= getFeature().getBiomeStrengthThreshold()) {
LoaderBiome b = biome.getLoader().getBiomeLoader().load(getFeature().getCustomBiome());
IrisBiome b = biome.getLoader().getBiomeLoader().load(getFeature().getCustomBiome());
b.setInferredType(biome.getInferredType());
return b;
}

16
src/main/java/com/volmit/iris/engine/object/jigsaw/LoaderJigsawPiece.java → src/main/java/com/volmit/iris/engine/object/jigsaw/IrisJigsawPiece.java
View File

@@ -21,13 +21,13 @@ package com.volmit.iris.engine.object.jigsaw;
import com.volmit.iris.Iris;
import com.volmit.iris.engine.data.cache.AtomicCache;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.object.objects.ObjectPlaceMode;
import com.volmit.iris.engine.object.annotations.ArrayType;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.RegistryListResource;
import com.volmit.iris.engine.object.annotations.Required;
import com.volmit.iris.engine.object.objects.LoaderObject;
import com.volmit.iris.engine.object.objects.IrisObject;
import com.volmit.iris.engine.object.objects.IrisObjectPlacement;
import com.volmit.iris.util.collection.KList;
import lombok.AllArgsConstructor;
@@ -47,8 +47,8 @@ import java.io.IOException;
@Desc("Represents a structure tile")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderJigsawPiece extends LoaderRegistrant {
@RegistryListResource(LoaderObject.class)
public class IrisJigsawPiece extends IrisRegistrant {
@RegistryListResource(IrisObject.class)
@Required
@Desc("The object this piece represents")
private String object = "";
@@ -67,7 +67,7 @@ public class LoaderJigsawPiece extends LoaderRegistrant {
public int getMax2dDimension() {
return max2dDim.aquire(() -> {
try {
BlockVector v = LoaderObject.sampleSize(getLoader().getObjectLoader().findFile(getObject()));
BlockVector v = IrisObject.sampleSize(getLoader().getObjectLoader().findFile(getObject()));
return Math.max(v.getBlockX(), v.getBlockZ());
} catch (IOException e) {
Iris.reportError(e);
@@ -81,7 +81,7 @@ public class LoaderJigsawPiece extends LoaderRegistrant {
public int getMax3dDimension() {
return max3dDim.aquire(() -> {
try {
BlockVector v = LoaderObject.sampleSize(getLoader().getObjectLoader().findFile(getObject()));
BlockVector v = IrisObject.sampleSize(getLoader().getObjectLoader().findFile(getObject()));
return Math.max(Math.max(v.getBlockX(), v.getBlockZ()), v.getBlockY());
} catch (IOException e) {
Iris.reportError(e);
@@ -103,8 +103,8 @@ public class LoaderJigsawPiece extends LoaderRegistrant {
return null;
}
public LoaderJigsawPiece copy() {
LoaderJigsawPiece p = new LoaderJigsawPiece();
public IrisJigsawPiece copy() {
IrisJigsawPiece p = new IrisJigsawPiece();
p.setObject(getObject());
p.setLoader(getLoader());
p.setLoadKey(getLoadKey());

6
src/main/java/com/volmit/iris/engine/object/jigsaw/IrisJigsawPieceConnector.java
View File

@@ -19,7 +19,7 @@
package com.volmit.iris.engine.object.jigsaw;
import com.volmit.iris.engine.object.objects.IrisDirection;
import com.volmit.iris.engine.object.entity.LoaderEntity;
import com.volmit.iris.engine.object.entity.IrisEntity;
import com.volmit.iris.engine.object.basic.IrisPosition;
import com.volmit.iris.engine.object.annotations.*;
import com.volmit.iris.util.collection.KList;
@@ -52,13 +52,13 @@ public class IrisJigsawPieceConnector {
@Desc("If set to true, this connector is allowed to place pieces inside of it's own piece. For example if you are adding a light post, or house on top of a path piece, you would set this to true to allow the piece to collide with the path bounding box.")
private boolean innerConnector = false;
@RegistryListResource(LoaderJigsawPool.class)
@RegistryListResource(IrisJigsawPool.class)
@Desc("Pick piece pools to place onto this connector")
@ArrayType(type = String.class, min = 1)
@Required
private KList<String> pools = new KList<>();
@RegistryListResource(LoaderEntity.class)
@RegistryListResource(IrisEntity.class)
@Desc("Pick an entity to spawn on this connector")
private String spawnEntity;

2
src/main/java/com/volmit/iris/engine/object/jigsaw/IrisJigsawPlacement.java
View File

@@ -33,7 +33,7 @@ import lombok.experimental.Accessors;
@Desc("Represents a jigsaw placement")
@Data
public class IrisJigsawPlacement {
@RegistryListResource(LoaderJigsawStructure.class)
@RegistryListResource(IrisJigsawStructure.class)
@Required
@Desc("The jigsaw structure to use")
private String structure = "";

6
src/main/java/com/volmit/iris/engine/object/jigsaw/LoaderJigsawPool.java → src/main/java/com/volmit/iris/engine/object/jigsaw/IrisJigsawPool.java
View File

@@ -18,7 +18,7 @@
package com.volmit.iris.engine.object.jigsaw;
import com.volmit.iris.core.project.loader.LoaderRegistrant;
import com.volmit.iris.core.project.loader.IrisRegistrant;
import com.volmit.iris.engine.object.annotations.ArrayType;
import com.volmit.iris.engine.object.annotations.Desc;
import com.volmit.iris.engine.object.annotations.RegistryListResource;
@@ -38,8 +38,8 @@ import lombok.experimental.Accessors;
@Desc("Represents a structure piece pool")
@Data
@EqualsAndHashCode(callSuper = false)
public class LoaderJigsawPool extends LoaderRegistrant {
@RegistryListResource(LoaderJigsawPiece.class)
public class IrisJigsawPool extends IrisRegistrant {
@RegistryListResource(IrisJigsawPiece.class)
@Required
@ArrayType(min = 1, type = String.class)
@Desc("A list of structure piece pools")

Some files were not shown because too many files have changed in this diff Show More