Repo-Mirror/Iris-World-Engine
9
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2026-01-06 15:51:30 +00:00
Code Issues Releases Activity

NV

Browse Source
This commit is contained in:
Dan Macbook
2020-08-13 05:42:02 -04:00
parent b1663c040f
commit 6c014e25b5
17 changed files with 890 additions and 332 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
src/main/java/com/volmit/iris/gen/ContextualChunkGenerator.java
View File

@@ -33,7 +33,9 @@ import com.volmit.iris.object.IrisRegion;
import com.volmit.iris.object.IrisStructure;
import com.volmit.iris.util.B;
import com.volmit.iris.util.ChronoLatch;
import com.volmit.iris.util.IrisLock;
import com.volmit.iris.util.J;
import com.volmit.iris.util.M;
import com.volmit.iris.util.PrecisionStopwatch;
import com.volmit.iris.util.RNG;
@@ -43,8 +45,7 @@ import net.md_5.bungee.api.ChatColor;
@Data
@EqualsAndHashCode(callSuper = false)
public abstract class ContextualChunkGenerator extends ChunkGenerator implements Listener
{
public abstract class ContextualChunkGenerator extends ChunkGenerator implements Listener {
private IrisDataManager data;
protected boolean failing;
protected int task;
@@ -55,17 +56,20 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
protected ChronoLatch tickLatch;
protected ChronoLatch pushLatch;
protected IrisMetrics metrics;
protected IrisLock hlock;
protected World world;
protected int generated;
protected int ticks;
protected long hlast;
private boolean fastPregen = false;
protected boolean pregenDone;
public ContextualChunkGenerator()
{
public ContextualChunkGenerator() {
pushLatch = new ChronoLatch(3000);
tickLatch = new ChronoLatch(650);
perSecond = new ChronoLatch(1000);
hlast = M.ms();
hlock = new IrisLock("HotLock");
CNG.creates = 0;
generated = 0;
ticks = 0;
@@ -94,45 +98,36 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
protected abstract void onPlayerLeft(Player p);
public IrisRegion loadRegion(String i)
{
public IrisRegion loadRegion(String i) {
return getData().getRegionLoader().load(i);
}
public IrisBiome loadBiome(String i)
{
public IrisBiome loadBiome(String i) {
return getData().getBiomeLoader().load(i);
}
public IrisStructure loadStructure(String i)
{
public IrisStructure loadStructure(String i) {
return getData().getStructureLoader().load(i);
}
public IrisObject loadObject(String i)
{
public IrisObject loadObject(String i) {
return getData().getObjectLoader().load(i);
}
public IrisDimension loadDimension(String i)
{
public IrisDimension loadDimension(String i) {
return (getData() == null ? Iris.globaldata : getData()).getDimensionLoader().load(i);
}
public IrisGenerator loadGenerator(String i)
{
public IrisGenerator loadGenerator(String i) {
return getData().getGeneratorLoader().load(i);
}
public IrisDataManager getData()
{
public IrisDataManager getData() {
return isDev() ? Iris.globaldata : data;
}
private void init(World world, RNG rng)
{
if(initialized)
{
private void init(World world, RNG rng) {
if (initialized) {
return;
}
@@ -146,27 +141,23 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
onInit(world, masterRandom);
}
private void tick()
{
if(dev)
{
if(perSecond.flip())
{
if(generated > (fastPregen ? 1950 : 770))
{
private void tick() {
if (dev) {
if (perSecond.flip()) {
if (generated > (fastPregen ? 1950 : 770)) {
pregenDone = true;
}
if(pregenDone)
{
if (pregenDone) {
metrics.getPerSecond().put(generated);
generated = 0;
}
checkHotload();
}
}
else
{
else {
pregenDone = true;
fastPregen = false;
}
@@ -175,100 +166,80 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
}
@EventHandler
public void on(PlayerTeleportEvent e)
{
if(e.getFrom().getWorld().equals(world) && !e.getTo().getWorld().equals(world))
{
public void on(PlayerTeleportEvent e) {
if (e.getFrom().getWorld().equals(world) && !e.getTo().getWorld().equals(world)) {
tick();
onPlayerLeft(e.getPlayer());
}
if(!e.getFrom().getWorld().equals(world) && e.getTo().getWorld().equals(world))
{
if (!e.getFrom().getWorld().equals(world) && e.getTo().getWorld().equals(world)) {
tick();
onPlayerJoin(e.getPlayer());
}
}
@EventHandler
public void on(PlayerQuitEvent e)
{
if(e.getPlayer().getWorld().equals(world))
{
public void on(PlayerQuitEvent e) {
if (e.getPlayer().getWorld().equals(world)) {
tick();
onPlayerLeft(e.getPlayer());
}
}
@EventHandler
public void on(PlayerJoinEvent e)
{
if(e.getPlayer().getWorld().equals(world))
{
public void on(PlayerJoinEvent e) {
if (e.getPlayer().getWorld().equals(world)) {
tick();
onPlayerJoin(e.getPlayer());
}
}
@EventHandler
public void on(ChunkLoadEvent e)
{
if(e.getWorld().equals(world))
{
public void on(ChunkLoadEvent e) {
if (e.getWorld().equals(world)) {
tick();
onChunkLoaded(e.getChunk());
}
}
@EventHandler
public void on(ChunkUnloadEvent e)
{
if(e.getWorld().equals(world))
{
public void on(ChunkUnloadEvent e) {
if (e.getWorld().equals(world)) {
tick();
onChunkUnloaded(e.getChunk());
}
}
@EventHandler
public void on(WorldUnloadEvent e)
{
if(world != null && e.getWorld().equals(world))
{
public void on(WorldUnloadEvent e) {
if (world != null && e.getWorld().equals(world)) {
close();
}
}
public void close()
{
public void close() {
HandlerList.unregisterAll(this);
Bukkit.getScheduler().cancelTask(getTask());
onClose();
}
@Override
public boolean canSpawn(World world, int x, int z)
{
public boolean canSpawn(World world, int x, int z) {
return super.canSpawn(world, x, z);
}
protected ChunkData generateChunkDataFailure(World world, Random no, int x, int z, BiomeGrid biomeGrid)
{
protected ChunkData generateChunkDataFailure(World world, Random no, int x, int z, BiomeGrid biomeGrid) {
ChunkData c = Bukkit.createChunkData(world);
for(int i = 0; i < 16; i++)
{
for(int j = 0; j < 16; j++)
{
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
int h = 0;
if(j == i || j + i == 16)
{
if (j == i || j + i == 16) {
c.setBlock(i, h, j, B.getBlockData("RED_TERRACOTTA"));
}
else
{
else {
c.setBlock(i, h, j, B.getBlockData("BLACK_TERRACOTTA"));
}
}
@@ -277,23 +248,18 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
return c;
}
protected ChunkData generateChunkFastPregen(World world, Random no, int x, int z, BiomeGrid biomeGrid)
{
protected ChunkData generateChunkFastPregen(World world, Random no, int x, int z, BiomeGrid biomeGrid) {
ChunkData c = Bukkit.createChunkData(world);
for(int i = 0; i < 16; i++)
{
for(int j = 0; j < 16; j++)
{
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
int h = 0;
if(j == i || j + i == 16)
{
if (j == i || j + i == 16) {
c.setBlock(i, h, j, B.getBlockData("BLUE_TERRACOTTA"));
}
else
{
else {
c.setBlock(i, h, j, B.getBlockData("WHITE_TERRACOTTA"));
}
}
@@ -303,51 +269,33 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
}
@Override
public ChunkData generateChunkData(World world, Random no, int x, int z, BiomeGrid biomeGrid)
{
if(!dev)
{
public ChunkData generateChunkData(World world, Random no, int x, int z, BiomeGrid biomeGrid) {
hlock.getLock();
if (!dev) {
pregenDone = true;
fastPregen = false;
}
PrecisionStopwatch sx = PrecisionStopwatch.start();
if(failing)
{
if (failing) {
hlock.unlock();
return generateChunkDataFailure(world, no, x, z, biomeGrid);
}
try
{
if(pushLatch.flip())
{
if(this.world == null)
{
this.world = world;
}
Iris.hotloader.check((IrisContext) this);
if(this instanceof IrisContext)
{
IrisContext.pushContext((IrisContext) this);
}
}
try {
checkHotload(world);
PrecisionStopwatch s = PrecisionStopwatch.start();
RNG random = new RNG(world.getSeed());
init(world, random.nextParallelRNG(0));
ChunkData c = Bukkit.createChunkData(world);
if(!pregenDone && fastPregen)
{
if (!pregenDone && fastPregen) {
c = generateChunkFastPregen(world, no, x, z, biomeGrid);
}
else
{
else {
onGenerate(random, x, z, c, biomeGrid);
}
@@ -357,46 +305,73 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
CNG.hits = 0;
Iris.instance.hit(hits);
metrics.getLoss().put(sx.getMilliseconds() - s.getMilliseconds());
hlock.unlock();
return c;
}
catch(Throwable e)
{
catch (Throwable e) {
fail(e);
}
hlock.unlock();
return generateChunkDataFailure(world, no, x, z, biomeGrid);
}
public void onHotload()
{
public void checkHotload() {
if (M.ms() - hlast < 1000) {
return;
}
hlock.lock();
if (world != null) {
checkHotload(world);
}
hlock.unlock();
}
protected void fail(Throwable e)
{
if(failing)
{
private void checkHotload(World world) {
if (pushLatch.flip()) {
if (this.world == null) {
this.world = world;
}
Iris.hotloader.check((IrisContext) this);
if (this instanceof IrisContext) {
IrisContext.pushContext((IrisContext) this);
}
}
}
public void onHotload() {
hlast = M.ms();
}
protected void fail(Throwable e) {
if (failing) {
return;
}
failing = true;
e.printStackTrace();
J.a(() ->
{
J.a(() -> {
J.sleep(1000);
Iris.error("---------------------------------------------------------------------------------------------------------");
Iris.error(
"---------------------------------------------------------------------------------------------------------");
e.printStackTrace();
Iris.error("---------------------------------------------------------------------------------------------------------");
Iris.error(
"---------------------------------------------------------------------------------------------------------");
Iris.error("ERROR! Failed to generate chunk! Iris has entered a failed state!");
Iris.error("---------------------------------------------------------------------------------------------------------");
Iris.error(
"---------------------------------------------------------------------------------------------------------");
for(Player i : world.getPlayers())
{
Iris.instance.imsg(i, ChatColor.DARK_RED + "Iris Generator has entered a failed state!");
for (Player i : world.getPlayers()) {
Iris.instance.imsg(i, ChatColor.DARK_RED + "Iris Generator has crashed!");
Iris.instance.imsg(i, ChatColor.RED + "- Check the console for the error.");
Iris.instance.imsg(i, ChatColor.RED + "- Then simply run /iris dev");
Iris.instance.imsg(i, ChatColor.RED + "- To Regen, use /iris std open <dim>");
Iris.instance.imsg(i, ChatColor.RED + "- To Retry the chunk, use /iris world retry");
}
});
@@ -404,20 +379,17 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
}
@Override
public List<BlockPopulator> getDefaultPopulators(World world)
{
public List<BlockPopulator> getDefaultPopulators(World world) {
return super.getDefaultPopulators(world);
}
@Override
public Location getFixedSpawnLocation(World world, Random random)
{
public Location getFixedSpawnLocation(World world, Random random) {
return super.getFixedSpawnLocation(world, random);
}
@Override
public boolean isParallelCapable()
{
public boolean isParallelCapable() {
return true;
}
}

107
src/main/java/com/volmit/iris/gen/IrisChunkGenerator.java
View File

@@ -25,98 +25,92 @@ import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode(callSuper = false)
public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisContext
{
public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisContext {
private Method initLighting;
private IrisLock lock;
private KMap<Player, IrisBiome> b = new KMap<>();
public IrisChunkGenerator(String dimensionName, int threads)
{
public IrisChunkGenerator(String dimensionName, int threads) {
super(dimensionName, threads);
lock = new IrisLock("IrisChunkGenerator");
}
public IrisChunkGenerator(String dimensionName)
{
public IrisChunkGenerator(String dimensionName) {
super(dimensionName, 16);
lock = new IrisLock("IrisChunkGenerator");
}
public IrisChunkGenerator(int tc)
{
public IrisChunkGenerator(int tc) {
super("", tc);
lock = new IrisLock("IrisChunkGenerator");
}
public void hotload() {
onHotload();
}
public void retry() {
if (failing) {
failing = false;
hotload();
}
}
@Override
protected void onGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid)
{
protected void onGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid) {
lock.lock();
super.onGenerate(random, x, z, data, grid);
lock.unlock();
}
public void onInit(World world, RNG rng)
{
try
{
public void onInit(World world, RNG rng) {
try {
super.onInit(world, rng);
}
catch(Throwable e)
{
catch (Throwable e) {
fail(e);
}
}
@Override
public BiomeResult getBiome(int x, int z)
{
public BiomeResult getBiome(int x, int z) {
return sampleBiome(x, z);
}
@Override
public IrisRegion getRegion(int x, int z)
{
public IrisRegion getRegion(int x, int z) {
return sampleRegion(x, z);
}
@Override
public int getHeight(int x, int z)
{
public int getHeight(int x, int z) {
return sampleHeight(x, z);
}
@Override
public void onTick(int ticks)
{
public void onTick(int ticks) {
super.onTick(ticks);
for(Player i : getWorld().getPlayers())
{
for (Player i : getWorld().getPlayers()) {
Location l = i.getLocation();
IrisRegion r = sampleRegion(l.getBlockX(), l.getBlockZ());
IrisBiome b = sampleTrueBiome(l.getBlockX(), l.getBlockY(), l.getBlockZ()).getBiome();
for(IrisEffect j : r.getEffects())
{
for (IrisEffect j : r.getEffects()) {
j.apply(i, this);
}
for(IrisEffect j : b.getEffects())
{
for (IrisEffect j : b.getEffects()) {
j.apply(i, this);
}
}
}
@Override
protected void onClose()
{
protected void onClose() {
super.onClose();
try
{
try {
parallaxMap.saveAll();
ceilingParallaxMap.saveAll();
parallaxMap.getLoadedChunks().clear();
@@ -125,8 +119,7 @@ public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisCon
ceilingParallaxMap.getLoadedRegions().clear();
}
catch(IOException e)
{
catch (IOException e) {
e.printStackTrace();
}
@@ -141,54 +134,45 @@ public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisCon
}
@Override
protected void onFailure(Throwable e)
{
protected void onFailure(Throwable e) {
}
@Override
protected void onChunkLoaded(Chunk c)
{
protected void onChunkLoaded(Chunk c) {
}
@Override
protected void onChunkUnloaded(Chunk c)
{
protected void onChunkUnloaded(Chunk c) {
}
@Override
protected void onPlayerJoin(Player p)
{
protected void onPlayerJoin(Player p) {
}
@Override
public void onPlayerLeft(Player p)
{
public void onPlayerLeft(Player p) {
super.onPlayerLeft(p);
}
@Override
public void onHotloaded()
{
public void onHotloaded() {
CNG.creates = 0;
getData().dump();
onHotload();
}
public long guessMemoryUsage()
{
public long guessMemoryUsage() {
long bytes = 1024 * 1024 * (8 + (getThreads() / 3));
for(AtomicRegionData i : parallaxMap.getLoadedRegions().values())
{
for (AtomicRegionData i : parallaxMap.getLoadedRegions().values()) {
bytes += i.guessMemoryUsage();
}
for(AtomicRegionData i : ceilingParallaxMap.getLoadedRegions().values())
{
for (AtomicRegionData i : ceilingParallaxMap.getLoadedRegions().values()) {
bytes += i.guessMemoryUsage();
}
@@ -201,28 +185,23 @@ public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisCon
}
@Override
public boolean shouldGenerateCaves()
{
public boolean shouldGenerateCaves() {
return false;
}
@Override
public boolean shouldGenerateDecorations()
{
public boolean shouldGenerateDecorations() {
return false;
}
@Override
public boolean shouldGenerateMobs()
{
public boolean shouldGenerateMobs() {
return true;
}
@Override
public boolean shouldGenerateStructures()
{
if(!isInitialized())
{
public boolean shouldGenerateStructures() {
if (!isInitialized()) {
return false;
}