mirror of
https://github.com/VolmitSoftware/Iris.git
synced 2025-07-18 10:12:53 +00:00
670 lines
18 KiB
Java
670 lines
18 KiB
Java
package com.volmit.iris.manager;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.volmit.iris.Iris;
|
|
import com.volmit.iris.IrisSettings;
|
|
import com.volmit.iris.manager.report.Report;
|
|
import com.volmit.iris.manager.report.ReportType;
|
|
import com.volmit.iris.nms.INMS;
|
|
import com.volmit.iris.object.*;
|
|
import com.volmit.iris.scaffold.IrisWorldCreator;
|
|
import com.volmit.iris.scaffold.engine.Engine;
|
|
import com.volmit.iris.scaffold.engine.IrisAccess;
|
|
import com.volmit.iris.util.*;
|
|
import lombok.Data;
|
|
import net.md_5.bungee.api.ChatMessageType;
|
|
import net.md_5.bungee.api.chat.TextComponent;
|
|
import org.bukkit.*;
|
|
import org.zeroturnaround.zip.ZipUtil;
|
|
|
|
import java.awt.*;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.Objects;
|
|
import java.util.UUID;
|
|
|
|
@Data
|
|
public class IrisProject
|
|
{
|
|
private File path;
|
|
private String name;
|
|
private IrisAccess activeProvider;
|
|
|
|
public IrisProject(File path)
|
|
{
|
|
this.path = path;
|
|
this.name = path.getName();
|
|
}
|
|
|
|
public KList<Report> scanForErrors()
|
|
{
|
|
KList<Report> reports = new KList<>();
|
|
IrisDataManager data = new IrisDataManager(path);
|
|
|
|
for(int i = 0; i < getActiveProvider().getCompound().getSize(); i++)
|
|
{
|
|
Engine e = getActiveProvider().getCompound().getEngine(i);
|
|
IrisDimension dim = e.getDimension();
|
|
reports.add(scanForErrors(dim));
|
|
}
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrors(IrisDimension dim) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
if(dim.getFocus() != null && !dim.getFocus().isEmpty())
|
|
{
|
|
reports.add(Report.builder()
|
|
.type(ReportType.NOTICE)
|
|
.title("Focus Mode is Enabled")
|
|
.message("Make sure to disable this before pushing")
|
|
.suggestion("Turn off focus mode")
|
|
.build());
|
|
}
|
|
|
|
for(IrisRegion i : dim.getAllRegions(getActiveProvider()))
|
|
{
|
|
scanForErrors(i);
|
|
}
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrors(IrisRegion region) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
if(region.getRarity() > 60)
|
|
{
|
|
reports.add(Report.builder()
|
|
.type(ReportType.WARNING)
|
|
.title("Region " + region.getName() + " has a rarity of " + region.getRarity())
|
|
.message("The region rarity higher than 60 can cause performance issues")
|
|
.suggestion("Scale all rarities down by 50% all at once, then repeat until all rarities are below 60")
|
|
.build());
|
|
}
|
|
|
|
for(IrisBiome i : region.getAllBiomes(getActiveProvider()))
|
|
{
|
|
reports.add(scanForErrors(i));
|
|
}
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrors(IrisBiome biome) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
for(IrisObjectPlacement i : biome.getObjects())
|
|
{
|
|
reports.add(scanForErrors(biome, i));
|
|
}
|
|
|
|
for(IrisBiomePaletteLayer i : biome.getLayers())
|
|
{
|
|
reports.add(scanForErrors(biome, i));
|
|
}
|
|
|
|
for(IrisBiomePaletteLayer i : biome.getSeaLayers())
|
|
{
|
|
reports.add(scanForErrorsSeaLayers(biome, i));
|
|
}
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrors(IrisBiome biome, IrisObjectPlacement i) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrors(IrisBiome biome, IrisBiomePaletteLayer i) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
return reports;
|
|
}
|
|
|
|
private KList<Report> scanForErrorsSeaLayers(IrisBiome biome, IrisBiomePaletteLayer i) {
|
|
KList<Report> reports = new KList<>();
|
|
|
|
return reports;
|
|
}
|
|
|
|
public boolean isOpen()
|
|
{
|
|
return activeProvider != null;
|
|
}
|
|
|
|
public KList<File> collectFiles(File f, String json)
|
|
{
|
|
KList<File> l = new KList<>();
|
|
|
|
if(f.isDirectory())
|
|
{
|
|
for(File i : f.listFiles())
|
|
{
|
|
l.addAll(collectFiles(i, json));
|
|
}
|
|
}
|
|
|
|
else if(f.getName().endsWith("."+json))
|
|
{
|
|
l.add(f);
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
public KList<File> collectFiles(String json) {
|
|
return collectFiles(path, json);
|
|
}
|
|
|
|
public void open(MortarSender sender)
|
|
{
|
|
open(sender, () ->
|
|
{
|
|
});
|
|
}
|
|
|
|
public void open(MortarSender sender, Runnable onDone)
|
|
{
|
|
if(isOpen())
|
|
{
|
|
close();
|
|
}
|
|
|
|
IrisDimension d = IrisDataManager.loadAnyDimension(getName());
|
|
if(d == null)
|
|
{
|
|
sender.sendMessage("Can't find dimension: " + getName());
|
|
return;
|
|
} else if(sender.isPlayer()){
|
|
sender.player().setGameMode(GameMode.SPECTATOR);
|
|
sender.player().spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(C.BLUE + "Creating studio world. Please wait..."));
|
|
}
|
|
|
|
J.attemptAsync(() ->
|
|
{
|
|
try
|
|
{
|
|
if (d.getLoader() == null){
|
|
sender.sendMessage("Could not get dimension loader");
|
|
return;
|
|
}
|
|
File f = d.getLoader().getDataFolder();
|
|
boolean foundWork = false;
|
|
for(File i : Objects.requireNonNull(f.listFiles()))
|
|
{
|
|
if(i.getName().endsWith(".code-workspace"))
|
|
{
|
|
foundWork = true;
|
|
sender.sendMessage("Updating Workspace...");
|
|
J.a(() ->
|
|
{
|
|
updateWorkspace();
|
|
sender.sendMessage("Workspace Updated");
|
|
});
|
|
|
|
if(IrisSettings.get().getStudio().isOpenVSCode())
|
|
{
|
|
if (!GraphicsEnvironment.isHeadless()) {
|
|
Iris.msg("Opening VSCode. You may see the output from VSCode.");
|
|
Iris.msg("VSCode output always starts with: '(node:#####) electron'");
|
|
Desktop.getDesktop().open(i);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!foundWork)
|
|
{
|
|
File ff = new File(d.getLoader().getDataFolder(), d.getLoadKey() + ".code-workspace");
|
|
Iris.warn("Project missing code-workspace: " + ff.getAbsolutePath() + " Re-creating code workspace.");
|
|
|
|
try
|
|
{
|
|
IO.writeAll(ff, createCodeWorkspaceConfig());
|
|
}
|
|
|
|
catch(IOException e1)
|
|
{
|
|
e1.printStackTrace();
|
|
}
|
|
sender.sendMessage("Updating Workspace...");
|
|
updateWorkspace();
|
|
sender.sendMessage("Workspace Updated");
|
|
}
|
|
}
|
|
|
|
catch(Throwable e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
});
|
|
|
|
String wfp = "iris/" + UUID.randomUUID();
|
|
|
|
WorldCreator c = new IrisWorldCreator().dimension(getName())
|
|
.seed(1337)
|
|
.name(wfp)
|
|
.studioMode()
|
|
.create();
|
|
|
|
IrisAccess gx = ((IrisAccess)c.generator());
|
|
sender.sendMessage("Generating with " + Iris.getThreadCount() + " threads per chunk");
|
|
O<Boolean> done = new O<>();
|
|
done.set(false);
|
|
activeProvider = gx;
|
|
|
|
J.a(() ->
|
|
{
|
|
double last = 0;
|
|
int req = 300;
|
|
double lpc = 0;
|
|
boolean fc;
|
|
|
|
while(!done.get())
|
|
{
|
|
boolean derp = false;
|
|
|
|
assert gx != null;
|
|
double v = (double) gx.getGenerated() / (double) req;
|
|
fc = lpc != v;
|
|
lpc = v;
|
|
|
|
if(last > v || v > 1)
|
|
{
|
|
derp = true;
|
|
v = last;
|
|
}
|
|
|
|
else
|
|
{
|
|
last = v;
|
|
}
|
|
|
|
if(fc)
|
|
{
|
|
sender.sendMessage(C.WHITE + "Generating " + Form.pc(v) + (derp ? (C.GRAY + " (Waiting on Server...)") : (C.GRAY + " (" + (req - gx.getGenerated()) + " Left)")));
|
|
}
|
|
|
|
if (sender.isPlayer()){
|
|
sender.player().spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(C.BLUE + "Creating studio world. Please wait..."));
|
|
}
|
|
|
|
J.sleep(1500);
|
|
|
|
if(gx.isFailing())
|
|
{
|
|
|
|
sender.sendMessage("Generation Failed!");
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
|
|
//@builder
|
|
World world = INMS.get().createWorld(c);
|
|
if (IrisSettings.get().getStudio().isDisableTimeAndWeather()) {
|
|
world.setGameRule(GameRule.DO_WEATHER_CYCLE, false);
|
|
world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
|
|
world.setTime(6000);
|
|
}
|
|
Iris.linkMultiverseCore.removeFromConfig(world);
|
|
|
|
done.set(true);
|
|
sender.sendMessage(C.WHITE + "Generating Complete!");
|
|
|
|
if(sender.isPlayer())
|
|
{
|
|
assert world != null;
|
|
sender.player().teleport(world.getSpawnLocation());
|
|
}
|
|
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(Iris.instance, () ->
|
|
{
|
|
sender.sendMessage("Hotloading Active! Change any files and watch your changes appear as you load new chunks!");
|
|
|
|
if(sender.isPlayer())
|
|
{
|
|
sender.player().setGameMode(GameMode.SPECTATOR);
|
|
}
|
|
|
|
onDone.run();
|
|
}, 0);
|
|
}
|
|
|
|
public void close()
|
|
{
|
|
activeProvider.close();
|
|
File folder = activeProvider.getTarget().getWorld().getWorldFolder();
|
|
Iris.linkMultiverseCore.removeFromConfig(activeProvider.getTarget().getWorld().getName());
|
|
Bukkit.unloadWorld(activeProvider.getTarget().getWorld().getName(), false);
|
|
J.attemptAsync(() -> IO.delete(folder));
|
|
activeProvider = null;
|
|
}
|
|
|
|
public File getCodeWorkspaceFile()
|
|
{
|
|
return new File(path, getName() + ".code-workspace");
|
|
}
|
|
|
|
public boolean updateWorkspace()
|
|
{
|
|
getPath().mkdirs();
|
|
File ws = getCodeWorkspaceFile();
|
|
|
|
try
|
|
{
|
|
PrecisionStopwatch p = PrecisionStopwatch.start();
|
|
Iris.info("Building Workspace: " + ws.getPath());
|
|
JSONObject j = createCodeWorkspaceConfig();
|
|
IO.writeAll(ws, j.toString(4));
|
|
p.end();
|
|
Iris.info("Building Workspace: " + ws.getPath() + " took " + Form.duration(p.getMilliseconds(), 2));
|
|
return true;
|
|
}
|
|
|
|
catch(Throwable e)
|
|
{
|
|
Iris.warn("Project invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
|
|
ws.delete();
|
|
try
|
|
{
|
|
IO.writeAll(ws, createCodeWorkspaceConfig());
|
|
}
|
|
|
|
catch(IOException e1)
|
|
{
|
|
e1.printStackTrace();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public JSONObject createCodeWorkspaceConfig()
|
|
{
|
|
JSONObject ws = new JSONObject();
|
|
JSONArray folders = new JSONArray();
|
|
JSONObject folder = new JSONObject();
|
|
folder.put("path", ".");
|
|
folders.put(folder);
|
|
ws.put("folders", folders);
|
|
JSONObject settings = new JSONObject();
|
|
settings.put("workbench.colorTheme", "Monokai");
|
|
settings.put("workbench.preferredDarkColorTheme", "Solarized Dark");
|
|
settings.put("workbench.tips.enabled", false);
|
|
settings.put("workbench.tree.indent", 24);
|
|
settings.put("files.autoSave", "onFocusChange");
|
|
JSONObject jc = new JSONObject();
|
|
jc.put("editor.autoIndent", "brackets");
|
|
jc.put("editor.acceptSuggestionOnEnter", "smart");
|
|
jc.put("editor.cursorSmoothCaretAnimation", true);
|
|
jc.put("editor.dragAndDrop", false);
|
|
jc.put("files.trimTrailingWhitespace", true);
|
|
jc.put("diffEditor.ignoreTrimWhitespace", true);
|
|
jc.put("files.trimFinalNewlines", true);
|
|
jc.put("editor.suggest.showKeywords", false);
|
|
jc.put("editor.suggest.showSnippets", false);
|
|
jc.put("editor.suggest.showWords", false);
|
|
JSONObject st = new JSONObject();
|
|
st.put("strings", true);
|
|
jc.put("editor.quickSuggestions", st);
|
|
jc.put("editor.suggest.insertMode", "replace");
|
|
settings.put("[json]", jc);
|
|
settings.put("json.maxItemsComputed", 30000);
|
|
JSONArray schemas = new JSONArray();
|
|
IrisDataManager dm = new IrisDataManager(getPath());
|
|
schemas.put(getSchemaEntry(IrisDimension.class, dm, "/dimensions/*.json"));
|
|
schemas.put(getSchemaEntry(IrisEntity.class, dm, "/entities/*.json"));
|
|
schemas.put(getSchemaEntry(IrisBiome.class, dm, "/biomes/*.json"));
|
|
schemas.put(getSchemaEntry(IrisRegion.class, dm, "/regions/*.json"));
|
|
schemas.put(getSchemaEntry(IrisGenerator.class,dm, "/generators/*.json"));
|
|
schemas.put(getSchemaEntry(IrisJigsawPiece.class, dm, "/jigsaw-pieces/*.json"));
|
|
schemas.put(getSchemaEntry(IrisJigsawPool.class, dm, "/jigsaw-pools/*.json"));
|
|
schemas.put(getSchemaEntry(IrisJigsawStructure.class, dm, "/jigsaw-structures/*.json"));
|
|
schemas.put(getSchemaEntry(IrisBlockData.class, dm, "/blocks/*.json"));
|
|
schemas.put(getSchemaEntry(IrisLootTable.class, dm, "/loot/*.json"));
|
|
settings.put("json.schemas", schemas);
|
|
ws.put("settings", settings);
|
|
|
|
return ws;
|
|
}
|
|
|
|
public JSONObject getSchemaEntry(Class<?> i, IrisDataManager dat, String... fileMatch)
|
|
{
|
|
Iris.verbose("Processing Folder " + i.getSimpleName() + " " + fileMatch[0]);
|
|
JSONObject o = new JSONObject();
|
|
o.put("fileMatch", new JSONArray(fileMatch));
|
|
o.put("schema", new SchemaBuilder(i, dat).compute());
|
|
|
|
return o;
|
|
}
|
|
|
|
public File compilePackage(MortarSender sender, boolean obfuscate, boolean minify)
|
|
{
|
|
String dimm = getName();
|
|
IrisDataManager dm = new IrisDataManager(path);
|
|
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<IrisRegion> regions = new KSet<>();
|
|
KSet<IrisBiome> biomes = new KSet<>();
|
|
KSet<IrisEntity> entities = 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));
|
|
}
|
|
|
|
//TODO: EXPORT JIGSAW PIECES FROM STRUCTURES
|
|
dimension.getRegions().forEach((i) -> regions.add(dm.getRegionLoader().load(i)));
|
|
dimension.getLoot().getTables().forEach((i) -> loot.add(dm.getLootLoader().load(i)));
|
|
regions.forEach((i) -> biomes.addAll(i.getAllBiomes(null)));
|
|
biomes.forEach((i) -> i.getGenerators().forEach((j) -> generators.add(j.getCachedGenerator(null))));
|
|
regions.forEach((r) -> r.getLoot().getTables().forEach((i) -> loot.add(dm.getLootLoader().load(i))));
|
|
biomes.forEach((r) -> r.getLoot().getTables().forEach((i) -> loot.add(dm.getLootLoader().load(i))));
|
|
biomes.forEach((r) -> r.getEntitySpawnOverrides().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity()))));
|
|
regions.forEach((r) -> r.getEntitySpawnOverrides().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity()))));
|
|
dimension.getEntitySpawnOverrides().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity())));
|
|
biomes.forEach((r) -> r.getEntityInitialSpawns().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity()))));
|
|
regions.forEach((r) -> r.getEntityInitialSpawns().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity()))));
|
|
dimension.getEntityInitialSpawns().forEach((sp) -> entities.add(dm.getEntityLoader().load(sp.getEntity())));
|
|
KMap<String, String> renameObjects = new KMap<>();
|
|
String a;
|
|
StringBuilder b = new StringBuilder();
|
|
StringBuilder c = new StringBuilder();
|
|
sender.sendMessage("Serializing Objects");
|
|
|
|
for(IrisBiome i : biomes)
|
|
{
|
|
for(IrisObjectPlacement j : i.getObjects())
|
|
{
|
|
b.append(j.hashCode());
|
|
KList<String> newNames = new KList<>();
|
|
|
|
for(String k : j.getPlace())
|
|
{
|
|
if(renameObjects.containsKey(k))
|
|
{
|
|
newNames.add(renameObjects.get(k));
|
|
continue;
|
|
}
|
|
|
|
String name = !obfuscate ? k : UUID.randomUUID().toString().replaceAll("-", "");
|
|
b.append(name);
|
|
newNames.add(name);
|
|
renameObjects.put(k, name);
|
|
}
|
|
|
|
j.setPlace(newNames);
|
|
}
|
|
}
|
|
|
|
for(IrisBiomeMutation i : dimension.getMutations())
|
|
{
|
|
for(IrisObjectPlacement j : i.getObjects())
|
|
{
|
|
b.append(j.hashCode());
|
|
KList<String> newNames = new KList<>();
|
|
|
|
for(String k : j.getPlace())
|
|
{
|
|
if(renameObjects.containsKey(k))
|
|
{
|
|
newNames.add(renameObjects.get(k));
|
|
continue;
|
|
}
|
|
|
|
String name = !obfuscate ? k : UUID.randomUUID().toString().replaceAll("-", "");
|
|
b.append(name);
|
|
newNames.add(name);
|
|
renameObjects.put(k, name);
|
|
}
|
|
|
|
j.setPlace(newNames);
|
|
}
|
|
}
|
|
|
|
KMap<String, KList<String>> lookupObjects = renameObjects.flip();
|
|
StringBuilder gb = new StringBuilder();
|
|
ChronoLatch cl = new ChronoLatch(1000);
|
|
O<Integer> ggg = new O<>();
|
|
ggg.set(0);
|
|
biomes.forEach((i) -> i.getObjects().forEach((j) -> j.getPlace().forEach((k) ->
|
|
{
|
|
try
|
|
{
|
|
File f = dm.getObjectLoader().findFile(lookupObjects.get(k).get(0));
|
|
IO.copyFile(f, new File(folder, "objects/" + k + ".iob"));
|
|
gb.append(IO.hash(f));
|
|
ggg.set(ggg.get() + 1);
|
|
|
|
if(cl.flip())
|
|
{
|
|
int g = ggg.get();
|
|
ggg.set(0);
|
|
sender.sendMessage("Wrote another " + g + " Objects");
|
|
}
|
|
}
|
|
|
|
catch(Throwable ignored)
|
|
{
|
|
|
|
}
|
|
})));
|
|
|
|
dimension.getMutations().forEach((i) -> i.getObjects().forEach((j) -> j.getPlace().forEach((k) ->
|
|
{
|
|
try
|
|
{
|
|
File f = dm.getObjectLoader().findFile(lookupObjects.get(k).get(0));
|
|
IO.copyFile(f, new File(folder, "objects/" + k + ".iob"));
|
|
gb.append(IO.hash(f));
|
|
ggg.set(ggg.get() + 1);
|
|
|
|
if(cl.flip())
|
|
{
|
|
int g = ggg.get();
|
|
ggg.set(0);
|
|
sender.sendMessage("Wrote another " + g + " Objects");
|
|
}
|
|
}
|
|
|
|
catch(Throwable ignored)
|
|
{
|
|
|
|
}
|
|
})));
|
|
|
|
b.append(IO.hash(gb.toString()));
|
|
c.append(IO.hash(b.toString()));
|
|
b = new StringBuilder();
|
|
|
|
Iris.info("Writing Dimensional Scaffold");
|
|
|
|
try
|
|
{
|
|
a = new JSONObject(new Gson().toJson(dimension)).toString(minify ? 0 : 4);
|
|
IO.writeAll(new File(folder, "dimensions/" + dimension.getLoadKey() + ".json"), a);
|
|
b.append(IO.hash(a));
|
|
|
|
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));
|
|
}
|
|
|
|
c.append(IO.hash(b.toString()));
|
|
b = new StringBuilder();
|
|
|
|
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(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(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(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(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));
|
|
}
|
|
|
|
c.append(IO.hash(b.toString()));
|
|
String finalHash = IO.hash(c.toString());
|
|
JSONObject meta = new JSONObject();
|
|
meta.put("hash", finalHash);
|
|
meta.put("time", M.ms());
|
|
meta.put("version", dimension.getVersion());
|
|
IO.writeAll(new File(folder, "package.json"), meta.toString(minify ? 0 : 4));
|
|
File p = new File(Iris.instance.getDataFolder(), "exports/" + dimension.getLoadKey() + ".iris");
|
|
Iris.info("Compressing Package");
|
|
ZipUtil.pack(folder, p, 9);
|
|
IO.delete(folder);
|
|
|
|
sender.sendMessage("Package Compiled!");
|
|
return p;
|
|
}
|
|
|
|
catch(Throwable e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
sender.sendMessage("Failed!");
|
|
return null;
|
|
}
|
|
}
|