mirrors/Terra
1
0
Fork 0
mirror of https://github.com/PolyhedralDev/Terra.git synced 2025-07-18 02:22:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement new parsing library, implement TerraProfiler

Browse Source
This commit is contained in:
dfsek 2020-09-13 02:18:26 -07:00
parent d626e8c735
commit 0eddcf429c
12 changed files with 146 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pom.xml
View File

@ -83,7 +83,7 @@
<dependency>
<groupId>org.polydev</groupId>
<artifactId>gaea</artifactId>
<version>1.4.0</version>
<version>1.5.7</version>
</dependency>
</dependencies>

62
src/main/java/com/dfsek/terra/Terra.java
View File

@ -1,75 +1,13 @@
package com.dfsek.terra;
import com.dfsek.terra.config.ConfigUtil;
import com.dfsek.terra.config.WorldConfig;
import com.dfsek.terra.math.NoiseFunction2;
import com.dfsek.terra.math.NoiseFunction3;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.generator.ChunkGenerator;
import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.polydev.gaea.math.parsii.eval.Expression;
import org.polydev.gaea.math.parsii.eval.Function;
import org.polydev.gaea.math.parsii.eval.Parser;
import java.util.List;
public class Terra extends JavaPlugin {
static {
Parser.registerFunction("floor", new Function() {
@Override
public int getNumberOfArguments() {
return 1;
}
@Override
public double eval(List<Expression> list) {
return Math.floor(list.get(0).evaluate());
}
@Override
public boolean isNaturalFunction() {
return true;
}
});
Parser.registerFunction("ceil", new Function() {
@Override
public int getNumberOfArguments() {
return 1;
}
@Override
public double eval(List<Expression> list) {
return Math.ceil(list.get(0).evaluate());
}
@Override
public boolean isNaturalFunction() {
return true;
}
});
Parser.registerFunction("round", new Function() {
@Override
public int getNumberOfArguments() {
return 1;
}
@Override
public double eval(List<Expression> list) {
return Math.round(list.get(0).evaluate());
}
@Override
public boolean isNaturalFunction() {
return true;
}
});
Parser.registerFunction("noise2", new NoiseFunction2());
Parser.registerFunction("noise3", new NoiseFunction3());
}
private static FileConfiguration config;
private static Terra instance;

44
src/main/java/com/dfsek/terra/TerraCommand.java
View File

@ -8,21 +8,45 @@ import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.polydev.gaea.profiler.WorldProfiler;
public class TerraCommand implements CommandExecutor {
@Override
public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
if(args.length == 1) {
switch(args[0]) {
case "reload":
ConfigUtil.loadConfig(Terra.getInstance());
sender.sendMessage("Reloaded Terra config.");
break;
case "biome":
if(!(sender instanceof Player)) return false;
sender.sendMessage("You are in " + ((UserDefinedBiome) TerraBiomeGrid.fromWorld(((Player) sender).getWorld()).getBiome(((Player) sender).getLocation())).getConfig().getFriendlyName());
switch(args[0]) {
case "reload":
ConfigUtil.loadConfig(Terra.getInstance());
sender.sendMessage("Reloaded Terra config.");
break;
case "biome":
if(!(sender instanceof Player)) return false;
sender.sendMessage("You are in " + ((UserDefinedBiome) TerraBiomeGrid.fromWorld(((Player) sender).getWorld()).getBiome(((Player) sender).getLocation())).getConfig().getFriendlyName());
case "profile":
if(! (sender instanceof Player)) {
sender.sendMessage("Command is for players only.");
return true;
}
Player p = (Player) sender;
if(p.getWorld().getGenerator() instanceof TerraChunkGenerator) {
WorldProfiler profile = TerraProfiler.fromWorld(p.getWorld());
if(args.length > 1 && "query".equals(args[1])) {
sender.sendMessage(profile.getResultsFormatted());
return true;
} else if(args.length > 1 && "reset".equals(args[1])) {
profile.reset();
sender.sendMessage("Profiler has been reset.");
return true;
} else if(args.length > 1 && "start".equals(args[1])) {
profile.setProfiling(true);
sender.sendMessage("Profiler has started.");
return true;
} else if(args.length > 1 && "stop".equals(args[1])) {
profile.setProfiling(false);
sender.sendMessage("Profiler has stopped.");
return true;
}
} else sender.sendMessage("World is not a Terra world!");
}
}
return true;
}
}

30
src/main/java/com/dfsek/terra/TerraProfiler.java Normal file
View File

@ -0,0 +1,30 @@
package com.dfsek.terra;
import org.bukkit.World;
import org.polydev.gaea.profiler.DataType;
import org.polydev.gaea.profiler.Measurement;
import org.polydev.gaea.profiler.WorldProfiler;
import java.util.HashMap;
import java.util.Map;
public class TerraProfiler extends WorldProfiler {
private static final Map<World, TerraProfiler> profilerMap = new HashMap<>();
public TerraProfiler(World w) {
super(w);
this.addMeasurement(new Measurement(2500000, DataType.PERIOD_MILLISECONDS), "TotalChunkGenTime")
.addMeasurement(new Measurement(2500000, DataType.PERIOD_MILLISECONDS), "ChunkBaseGenTime")
.addMeasurement(new Measurement(2000000, DataType.PERIOD_MILLISECONDS), "BiomeSetTime")
.addMeasurement(new Measurement(25000000, DataType.PERIOD_MILLISECONDS), "TreeGenTime")
.addMeasurement(new Measurement(1500000, DataType.PERIOD_MILLISECONDS), "FaunaTime");
profilerMap.put(w, this);
}
public static TerraProfiler fromWorld(World w) {
if(w.getGenerator() instanceof TerraChunkGenerator) {
if(profilerMap.containsKey(w)) return profilerMap.get(w);
TerraProfiler p = new TerraProfiler(w);
profilerMap.put(w, p);
return p;
} else throw new IllegalArgumentException("Attempted to instantiate/fetch Profiler for non-Terra world!");
}
}

25
src/main/java/com/dfsek/terra/biome/UserDefinedBiome.java
View File

@ -2,14 +2,18 @@ package com.dfsek.terra.biome;
import com.dfsek.terra.config.BiomeConfig;
import com.dfsek.terra.config.ConfigUtil;
import org.bukkit.Bukkit;
import org.bukkit.block.data.BlockData;
import org.bukkit.configuration.file.FileConfiguration;
import org.polydev.gaea.biome.Biome;
import org.polydev.gaea.biome.BiomeTerrain;
import org.polydev.gaea.biome.Decorator;
import org.polydev.gaea.math.ProbabilityCollection;
import org.polydev.gaea.math.parsii.eval.Parser;
import org.polydev.gaea.math.parsii.eval.Scope;
import org.polydev.gaea.math.parsii.tokenizer.ParseException;
import org.polydev.gaea.structures.features.Feature;
import org.polydev.gaea.tree.Tree;
import org.polydev.gaea.world.BlockPalette;
import java.util.Collections;
@ -24,16 +28,27 @@ public class UserDefinedBiome implements Biome {
private final UserDefinedDecorator decorator;
public UserDefinedBiome(BiomeConfig config) throws ParseException {
this.config = config;
Scope s = Scope.create();
TreeMap<Integer, BlockPalette> paletteMap = new TreeMap<>();
for(Map.Entry<String, Object> e : config.getConfigurationSection("palette").getValues(false).entrySet()) {
paletteMap.put((Integer) e.getValue(), ConfigUtil.getPalette(e.getKey()).getPalette());
for(Map<?, ?> e : config.getMapList("palette")) {
for(Map.Entry<?, ?> entry : e.entrySet()) {
try {
if(((String) entry.getKey()).startsWith("BLOCK:")) {
try {
paletteMap.put((Integer) entry.getValue(), new BlockPalette().addBlockData(new ProbabilityCollection<BlockData>().add(Bukkit.createBlockData((String) entry.getKey()), 1), 1));
} catch(IllegalArgumentException ex) {
Bukkit.getLogger().severe("SEVERE configuration error for BlockPalettes in biome" + config.getFriendlyName() + ", ID: " + config.getBiomeID() + ". BlockData " + entry.getKey() + " is invalid!");
}
}
else paletteMap.put((Integer) entry.getValue(), ConfigUtil.getPalette((String) entry.getKey()).getPalette());
} catch(ClassCastException ex) {
Bukkit.getLogger().severe("SEVERE configuration error for BlockPalettes in biome" + config.getFriendlyName() + ", ID: " + config.getBiomeID());
}
}
}
this.decorator = new UserDefinedDecorator(config);
gen = new UserDefinedGenerator(s, Parser.parse(Objects.requireNonNull(config.getString("noise-equation")), s), Collections.emptyList(), paletteMap);
gen = new UserDefinedGenerator(Objects.requireNonNull(config.getString("noise-equation")), Collections.emptyList(), paletteMap);
}
public BiomeConfig getConfig() {

56
src/main/java/com/dfsek/terra/biome/UserDefinedGenerator.java
View File

@ -1,12 +1,15 @@
package com.dfsek.terra.biome;
import com.dfsek.terra.Terra;
import com.dfsek.terra.math.NoiseFunction2;
import com.dfsek.terra.math.NoiseFunction3;
import org.polydev.gaea.biome.BiomeTerrain;
import org.polydev.gaea.math.FastNoise;
import org.polydev.gaea.math.parsii.eval.Expression;
import org.polydev.gaea.math.parsii.eval.Parser;
import org.polydev.gaea.math.parsii.eval.Scope;
import org.polydev.gaea.math.parsii.eval.Variable;
import org.polydev.gaea.math.parsii.tokenizer.ParseException;
import org.polydev.gaea.world.BlockPalette;
import java.util.List;
@ -16,19 +19,26 @@ import java.util.TreeMap;
public class UserDefinedGenerator extends BiomeTerrain {
private final Expression noiseExp;
private final List<Variable> vars;
private final Variable xVar;
private final Variable yVar;
private final Variable zVar;
private final Scope s = new Scope();
private final Variable xVar = s.getVariable("x");;
private final Variable yVar = s.getVariable("y");
private final Variable zVar = s.getVariable("z");;
private final TreeMap<Integer, BlockPalette> paletteMap;
private final NoiseFunction2 n2 = new NoiseFunction2();
private final NoiseFunction3 n3 = new NoiseFunction3();
private final Parser p = new Parser();
{
p.registerFunction("noise2", n2);
p.registerFunction("noise3", n3);
}
private static final Object noiseLock = new Object();
public UserDefinedGenerator(Scope s, Expression e, List<Variable> v, TreeMap<Integer, BlockPalette> p) {
this.noiseExp = e;
public UserDefinedGenerator(String e, List<Variable> v, TreeMap<Integer, BlockPalette> pa) throws ParseException {
this.vars = v;
this.paletteMap = p;
this.xVar = s.getVariable("x");
this.yVar = s.getVariable("y");
this.zVar = s.getVariable("z");
this.paletteMap = pa;
this.noiseExp = p.parse(e, s);
}
/**
* Gets the 2D noise at a pair of coordinates using the provided FastNoise instance.
@ -40,12 +50,14 @@ public class UserDefinedGenerator extends BiomeTerrain {
*/
@Override
public double getNoise(FastNoise gen, int x, int z) {
xVar.setValue(x);
yVar.setValue(0);
zVar.setValue(z);
NoiseFunction2.setNoise(gen);
NoiseFunction3.setNoise(gen);
return noiseExp.evaluate();
synchronized(noiseLock) {
xVar.setValue(x);
yVar.setValue(0);
zVar.setValue(z);
n2.setNoise(gen, false);
n3.setNoise(gen, false);
return noiseExp.evaluate();
}
}
/**
@ -59,12 +71,14 @@ public class UserDefinedGenerator extends BiomeTerrain {
*/
@Override
public double getNoise(FastNoise gen, int x, int y, int z) {
xVar.setValue(x);
yVar.setValue(y);
zVar.setValue(z);
NoiseFunction2.setNoise(gen);
NoiseFunction3.setNoise(gen);
return noiseExp.evaluate();
synchronized(noiseLock) {
xVar.setValue(x);
yVar.setValue(y);
zVar.setValue(z);
n2.setNoise(gen, false);
n3.setNoise(gen, false);
return noiseExp.evaluate();
}
}
/**

1
src/main/java/com/dfsek/terra/config/BiomeConfig.java
View File

@ -39,6 +39,7 @@ public class BiomeConfig extends YamlConfiguration {
if(!contains("name")) throw new InvalidConfigurationException("Biome Name unspecified!");
this.friendlyName = getString("name");
if(!contains("vanilla")) throw new InvalidConfigurationException("Vanila Biome unspecified!");
if(!contains("palette")) throw new InvalidConfigurationException("Palette unspecified!");
try {
this.vanillaBiome = org.bukkit.block.Biome.valueOf(getString("vanilla"));
} catch(IllegalArgumentException e) {

6
src/main/java/com/dfsek/terra/config/WorldConfig.java
View File

@ -66,9 +66,9 @@ public class WorldConfig {
}
seaLevel = config.getInt("sea-level", 63);
zoneFreq = config.getInt("frequencies.zone", 1536);
freq1 = config.getInt("frequencies.grid-1", 256);
freq2 = config.getInt("frequencies.grid-2", 512);
zoneFreq = 1f/config.getInt("frequencies.zone", 1536);
freq1 = 1f/config.getInt("frequencies.grid-1", 256);
freq2 = 1f/config.getInt("frequencies.grid-2", 512);
try (Stream<Path> paths = Files.walk(Paths.get(main.getDataFolder() + File.separator + "grids"))) {
paths

14
src/main/java/com/dfsek/terra/math/NoiseFunction2.java
View File

@ -7,7 +7,7 @@ import org.polydev.gaea.math.parsii.eval.Function;
import java.util.List;
public class NoiseFunction2 implements Function {
private static FastNoise gen = new FastNoise();
private FastNoise gen;
@Override
public int getNumberOfArguments() {
@ -19,16 +19,12 @@ public class NoiseFunction2 implements Function {
return gen.getSimplexFractal((float) list.get(0).evaluate(), (float) list.get(1).evaluate());
}
public void setNoise(FastNoise gen, boolean override) {
if(this.gen == null || override) this.gen = gen;
}
@Override
public boolean isNaturalFunction() {
return true;
}
public static void setNoise(FastNoise gen) {
NoiseFunction2.gen = gen;
}
public static FastNoise getNoise() {
return gen;
}
}

15
src/main/java/com/dfsek/terra/math/NoiseFunction3.java
View File

@ -7,8 +7,7 @@ import org.polydev.gaea.math.parsii.eval.Function;
import java.util.List;
public class NoiseFunction3 implements Function {
private static FastNoise gen = new FastNoise();
private FastNoise gen;
@Override
public int getNumberOfArguments() {
return 3;
@ -19,16 +18,12 @@ public class NoiseFunction3 implements Function {
return gen.getSimplexFractal((float) list.get(0).evaluate(), (float) list.get(1).evaluate(), (float) list.get(2).evaluate());
}
public void setNoise(FastNoise gen, boolean override) {
if(this.gen == null || override) this.gen = gen;
}
@Override
public boolean isNaturalFunction() {
return true;
}
public static void setNoise(FastNoise gen) {
NoiseFunction3.gen = gen;
}
public static FastNoise getNoise() {
return gen;
}
}

10
src/main/java/com/dfsek/terra/population/FaunaPopulator.java
View File

@ -1,5 +1,7 @@
package com.dfsek.terra.population;
import com.dfsek.terra.Terra;
import com.dfsek.terra.TerraProfiler;
import com.dfsek.terra.biome.TerraBiomeGrid;
import org.bukkit.Chunk;
import org.bukkit.World;
@ -7,6 +9,7 @@ import org.bukkit.block.Block;
import org.bukkit.generator.BlockPopulator;
import org.jetbrains.annotations.NotNull;
import org.polydev.gaea.biome.Biome;
import org.polydev.gaea.profiler.ProfileFuture;
import org.polydev.gaea.world.Fauna;
import java.util.Random;
@ -14,16 +17,19 @@ import java.util.Random;
public class FaunaPopulator extends BlockPopulator {
@Override
public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk chunk) {
ProfileFuture fauna = TerraProfiler.fromWorld(world).measure("FaunaTime");
for(int x = 0; x < 16; x++) {
for(int z = 0; z < 16; z++) {
Biome biome = TerraBiomeGrid.fromWorld(world).getBiome((chunk.getX() << 4) + x, (chunk.getZ() << 4) + z);
if(biome.getDecorator().getFaunaChance() <= 0 || random.nextInt(100) > biome.getDecorator().getFaunaChance())
continue;
Block highest = Fauna.getHighestValidSpawnAt(chunk, x, z);
Fauna item = biome.getDecorator().getFauna().get(random);
Block highest = item.getHighestValidSpawnAt(chunk, x, z);
try {
if(highest != null) biome.getDecorator().getFauna().get(random).plant(highest.getLocation());
if(highest != null) item.plant(highest.getLocation());
} catch(NullPointerException ignored) {}
}
}
if(fauna!=null) fauna.complete();
}
}

4
src/main/java/com/dfsek/terra/population/TreePopulator.java
View File

@ -1,6 +1,7 @@
package com.dfsek.terra.population;
import com.dfsek.terra.Terra;
import com.dfsek.terra.TerraProfiler;
import com.dfsek.terra.biome.TerraBiomeGrid;
import com.dfsek.terra.biome.UserDefinedDecorator;
import org.bukkit.Chunk;
@ -10,6 +11,7 @@ import org.jetbrains.annotations.NotNull;
import org.polydev.gaea.biome.Biome;
import org.polydev.gaea.population.GaeaBlockPopulator;
import org.polydev.gaea.population.PopulationManager;
import org.polydev.gaea.profiler.ProfileFuture;
import org.polydev.gaea.util.WorldUtil;
import java.util.Random;
@ -22,6 +24,7 @@ public class TreePopulator extends GaeaBlockPopulator {
@Override
public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk chunk) {
ProfileFuture tree = TerraProfiler.fromWorld(world).measure("TreeGenTime");
int x = random.nextInt(16); // Decrease chances of chunk-crossing trees
int z = random.nextInt(16);
Location origin = chunk.getBlock(x, 0, z).getLocation();
@ -41,5 +44,6 @@ public class TreePopulator extends GaeaBlockPopulator {
x = random.nextInt(16); // Decrease chances of chunk-crossing trees
z = random.nextInt(16);
}
if(tree!=null) tree.complete();
}
}