Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2025-06-28 14:36:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move Plex to API-driven plugin and fix NoClassDefFoundError on startup

Browse Source
This commit is contained in:
Focusvity
2022-04-24 14:16:14 +10:00
parent edeecb51f4
commit f9a577035b
346 changed files with 736 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
server/src/main/java/dev/plex/world/BlockMapChunkGenerator.java Normal file
View File

@ -0,0 +1,34 @@
package dev.plex.world;
import java.util.LinkedHashMap;
import java.util.Map;
import org.bukkit.Material;
import org.bukkit.generator.BlockPopulator;
public class BlockMapChunkGenerator extends FlatChunkGenerator
{
protected LinkedHashMap<Material, Integer> blockMap;
public BlockMapChunkGenerator(LinkedHashMap<Material, Integer> blockMap, BlockPopulator... populators)
{
super(0, populators);
this.blockMap = blockMap;
}
@Override
public void createLoopChunkData(int x, int y, int z, ChunkData chunk)
{
int height = -1;
for (int i : blockMap.values())
{
height += i;
}
for (Map.Entry<Material, Integer> entry : blockMap.entrySet())
{
for (int i = 0; i < entry.getValue(); i++, height--)
{
chunk.setBlock(x, height, z, entry.getKey());
}
}
}
}

32
server/src/main/java/dev/plex/world/ConfigurationChunkGenerator.java Normal file
View File

@ -0,0 +1,32 @@
package dev.plex.world;
import dev.plex.Plex;
import java.util.LinkedHashMap;
import org.bukkit.Material;
import org.bukkit.generator.BlockPopulator;
public class ConfigurationChunkGenerator extends BlockMapChunkGenerator
{
private static final Plex plugin = Plex.get();
public ConfigurationChunkGenerator(String worldName, BlockPopulator... populators)
{
super(createBlockMap(worldName), populators);
}
private static LinkedHashMap<Material, Integer> createBlockMap(String worldName)
{
LinkedHashMap<Material, Integer> blockMap = new LinkedHashMap<>();
for (String key : plugin.config.getConfigurationSection("worlds." + worldName + ".parameters").getKeys(false))
{
Material material = Material.getMaterial(key.toUpperCase());
if (material == null)
{
continue;
}
int count = plugin.config.getInt("worlds." + worldName + ".parameters." + key);
blockMap.put(material, count);
}
return blockMap;
}
}

27
server/src/main/java/dev/plex/world/CustomChunkGenerator.java Normal file
View File

@ -0,0 +1,27 @@
package dev.plex.world;
import java.util.Arrays;
import java.util.List;
import org.bukkit.World;
import org.bukkit.generator.BlockPopulator;
import org.bukkit.generator.ChunkGenerator;
public abstract class CustomChunkGenerator extends ChunkGenerator
{
private final List<BlockPopulator> populators;
protected int height;
protected CustomChunkGenerator(int height, BlockPopulator... populators)
{
this.height = height;
this.populators = Arrays.asList(populators);
}
@Override
public List<BlockPopulator> getDefaultPopulators(World world)
{
return populators;
}
public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);
}

71
server/src/main/java/dev/plex/world/CustomWorld.java Normal file
View File

@ -0,0 +1,71 @@
package dev.plex.world;
import dev.plex.Plex;
import java.io.File;
import java.util.Objects;
import net.kyori.adventure.text.Component;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.WorldCreator;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.generator.ChunkGenerator;
public class CustomWorld extends WorldCreator
{
private static final Plex plugin = Plex.get();
private final CustomChunkGenerator chunks;
public CustomWorld(String name, CustomChunkGenerator generator)
{
super(name);
this.chunks = generator;
this.generator(this.chunks);
}
public static World generateConfigFlatWorld(String name)
{
if (!plugin.config.contains("worlds." + name))
{
return null;
}
CustomWorld customWorld = new CustomWorld(name, new ConfigurationChunkGenerator(name))
{
@Override
public World generate()
{
boolean existed = new File(name).exists();
World world = super.generate();
if (!existed)
{
Block block = world.getBlockAt(0, world.getHighestBlockYAt(0, 0) + 1, 0);
block.setType(Material.OAK_SIGN);
BlockState state = block.getState();
if (state instanceof Sign sign)
{
sign.line(1, Component.text(
Objects.requireNonNull(plugin.config.getString("worlds." + name + ".name"))));
sign.line(2, Component.text("- 0, 0 -"));
sign.update();
}
}
return world;
}
};
return customWorld.generate();
}
@Override
public ChunkGenerator generator()
{
return chunks;
}
public World generate()
{
return this.createWorld();
}
}

27
server/src/main/java/dev/plex/world/FlatChunkGenerator.java Normal file
View File

@ -0,0 +1,27 @@
package dev.plex.world;
import java.util.Random;
import org.bukkit.generator.BlockPopulator;
import org.bukkit.generator.WorldInfo;
public abstract class FlatChunkGenerator extends CustomChunkGenerator
{
public FlatChunkGenerator(int height, BlockPopulator... populators)
{
super(height, populators);
}
@Override
public void generateSurface(WorldInfo worldInfo, Random random, int x, int z, ChunkData chunk)
{
for (int xx = 0; xx < 16; xx++)
{
for (int zz = 0; zz < 16; zz++)
{
createLoopChunkData(xx, height, zz, chunk);
}
}
}
public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);
}

33
server/src/main/java/dev/plex/world/NoiseChunkGenerator.java Normal file
View File

@ -0,0 +1,33 @@
package dev.plex.world;
import java.util.Random;
import org.bukkit.generator.BlockPopulator;
import org.bukkit.generator.WorldInfo;
import org.bukkit.util.noise.PerlinNoiseGenerator;
public abstract class NoiseChunkGenerator extends CustomChunkGenerator
{
private final NoiseOptions options;
public NoiseChunkGenerator(int height, NoiseOptions options, BlockPopulator... populators)
{
super(height, populators);
this.options = options;
}
@Override
public void generateNoise(WorldInfo worldInfo, Random random, int x, int z, ChunkData chunk)
{
PerlinNoiseGenerator generator = new PerlinNoiseGenerator(new Random(worldInfo.getSeed()));
for (int xx = 0; xx < 16; xx++)
{
for (int zz = 0; zz < 16; zz++)
{
height = (int)generator.noise(options.getX(), options.getY(), options.getFrequency(), options.getAmplitude(), options.isNormalized());
createLoopChunkData(xx, height, zz, chunk);
}
}
}
public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);
}

22
server/src/main/java/dev/plex/world/NoiseOptions.java Normal file
View File

@ -0,0 +1,22 @@
package dev.plex.world;
import lombok.Getter;
@Getter
public class NoiseOptions
{
private final int x;
private final int y;
private final double frequency;
private final double amplitude;
private final boolean normalized;
public NoiseOptions(int x, int y, double frequency, double amplitude, boolean normalized)
{
this.x = x;
this.y = y;
this.frequency = frequency;
this.amplitude = amplitude;
this.normalized = normalized;
}
}

34
server/src/main/java/dev/plex/world/OctaveChunkGenerator.java Normal file
View File

@ -0,0 +1,34 @@
package dev.plex.world;
import java.util.Random;
import org.bukkit.generator.BlockPopulator;
import org.bukkit.generator.WorldInfo;
import org.bukkit.util.noise.PerlinOctaveGenerator;
import org.jetbrains.annotations.NotNull;
public abstract class OctaveChunkGenerator extends CustomChunkGenerator
{
private final OctaveOptions options;
public OctaveChunkGenerator(int height, OctaveOptions options, BlockPopulator... populators)
{
super(height, populators);
this.options = options;
}
@Override
public void generateNoise(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z, @NotNull ChunkData chunk)
{
PerlinOctaveGenerator generator = new PerlinOctaveGenerator(new Random(worldInfo.getSeed()), options.getOctaves());
for (int xx = 0; xx < 16; xx++)
{
for (int zz = 0; zz < 16; zz++)
{
height = (int)generator.noise(options.getX(), options.getY(), options.getFrequency(), options.getAmplitude(), options.isNormalized());
createLoopChunkData(xx, height, zz, chunk);
}
}
}
public abstract void createLoopChunkData(int x, int y, int z, ChunkData chunk);
}

15
server/src/main/java/dev/plex/world/OctaveOptions.java Normal file
View File

@ -0,0 +1,15 @@
package dev.plex.world;
import lombok.Getter;
@Getter
public class OctaveOptions extends NoiseOptions
{
private final int octaves;
public OctaveOptions(int x, int y, double frequency, double amplitude, boolean normalized, int octaves)
{
super(x, y, frequency, amplitude, normalized);
this.octaves = octaves;
}
}