diff --git a/common/addons/config-ore/LICENSE b/common/addons/config-ore/LICENSE new file mode 100644 index 000000000..64c1cd516 --- /dev/null +++ b/common/addons/config-ore/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2021 Polyhedral Development + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/common/addons/config-ore/README.md b/common/addons/config-ore/README.md new file mode 100644 index 000000000..1b72835ea --- /dev/null +++ b/common/addons/config-ore/README.md @@ -0,0 +1,3 @@ +# config-ore + +Registers the default configuration for Terra Ores, `ORE`. \ No newline at end of file diff --git a/common/addons/config-ore/build.gradle.kts b/common/addons/config-ore/build.gradle.kts new file mode 100644 index 000000000..147905b20 --- /dev/null +++ b/common/addons/config-ore/build.gradle.kts @@ -0,0 +1,3 @@ +dependencies { + "shadedApi"(project(":common:addons:manifest-addon-loader")) +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java new file mode 100644 index 000000000..8ae1ff5be --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.addons.manifest.api.AddonInitializer; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; +import com.dfsek.terra.api.event.functional.FunctionalEventHandler; +import com.dfsek.terra.api.inject.annotations.Inject; +import com.dfsek.terra.api.world.generator.GenerationStageProvider; + + +public class OreAddon implements AddonInitializer { + @Inject + private Platform platform; + + @Inject + private BaseAddon addon; + + @Override + public void initialize() { + platform.getEventManager() + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + event.getPack().registerConfigType(new OreConfigType(), "ORE", 1); + event.getPack().getOrCreateRegistry(GenerationStageProvider.class).register("ORE", pack -> new OrePopulator(platform)); + }) + .failThrough(); + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java new file mode 100644 index 000000000..217595e5c --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import java.util.function.Supplier; + +import com.dfsek.terra.addons.ore.ores.Ore; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.config.ConfigFactory; +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.config.ConfigType; +import com.dfsek.terra.api.registry.OpenRegistry; +import com.dfsek.terra.api.util.reflection.TypeKey; + + +public class OreConfigType implements ConfigType { + public static final TypeKey ORE_TYPE_TOKEN = new TypeKey<>() { + }; + private final OreFactory factory = new OreFactory(); + + @Override + public OreTemplate getTemplate(ConfigPack pack, Platform platform) { + return new OreTemplate(); + } + + @Override + public ConfigFactory getFactory() { + return factory; + } + + @Override + public TypeKey getTypeKey() { + return ORE_TYPE_TOKEN; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java new file mode 100644 index 000000000..2a0910ebd --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.addons.ore.ores.Ore; +import com.dfsek.terra.addons.ore.ores.VanillaOre; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.ConfigFactory; + + +public class OreFactory implements ConfigFactory { + @Override + public Ore build(OreTemplate config, Platform platform) { + BlockState m = config.getMaterial(); + return new VanillaOre(m, config.getReplaceable(), config.doPhysics(), config.getSize(), platform, config.getMaterialOverrides()); + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OrePopulator.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OrePopulator.java new file mode 100644 index 000000000..441a5c8cd --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OrePopulator.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import org.jetbrains.annotations.NotNull; + +import java.util.Random; + +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.profiler.ProfileFrame; +import com.dfsek.terra.api.util.PopulationUtil; +import com.dfsek.terra.api.world.Chunk; +import com.dfsek.terra.api.world.World; +import com.dfsek.terra.api.world.biome.TerraBiome; +import com.dfsek.terra.api.world.generator.GenerationStage; + + +public class OrePopulator implements GenerationStage { + private final Platform platform; + + public OrePopulator(Platform platform) { + this.platform = platform; + } + + @SuppressWarnings("try") + @Override + public void populate(@NotNull World world, @NotNull Chunk chunk) { + try(ProfileFrame ignore = platform.getProfiler().profile("ore")) { + if(world.getConfig().disableOres()) return; + + for(int cx = -1; cx <= 1; cx++) { + for(int cz = -1; cz <= 1; cz++) { + Random random = new Random(PopulationUtil.getCarverChunkSeed(chunk.getX() + cx, chunk.getZ() + cz, world.getSeed())); + int originX = ((chunk.getX() + cx) << 4); + int originZ = ((chunk.getZ() + cz) << 4); + TerraBiome b = world.getBiomeProvider().getBiome(originX + 8, originZ + 8, world.getSeed()); + /* + BiomeTemplate config = ((UserDefinedBiome) b).getConfig(); + int finalCx = cx; + int finalCz = cz; + config.getOreHolder().forEach((id, orePair) -> { + try(ProfileFrame ignored = main.getProfiler().profile("ore:" + id)) { + int amount = orePair.getRight().getAmount().get(random); + for(int i = 0; i < amount; i++) { + Vector3 location = new Vector3(random.nextInt(16) + 16 * finalCx, orePair.getRight().getHeight().get + (random), random.nextInt(16) + 16 * finalCz); + orePair.getLeft().generate(location, chunk, random); + } + } + }); + + */ + } + } + } + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java new file mode 100644 index 000000000..0b5fdf0cd --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.tectonic.annotations.Default; +import com.dfsek.tectonic.annotations.Final; +import com.dfsek.tectonic.annotations.Value; + +import java.util.HashMap; +import java.util.Map; + +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.AbstractableTemplate; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.util.Range; +import com.dfsek.terra.api.util.collection.MaterialSet; + + +@SuppressWarnings({ "unused", "FieldMayBeFinal" }) +public class OreTemplate implements AbstractableTemplate { + @Value("id") + @Final + private String id; + + @Value("material") + private @Meta BlockState material; + + @Value("material-overrides") + @Default + private @Meta Map<@Meta BlockType, @Meta BlockState> materials = new HashMap<>(); + + @Value("replace") + private @Meta MaterialSet replaceable; + + @Value("physics") + @Default + private @Meta boolean physics = false; + + @Value("size") + private @Meta Range size; + + @Value("deform") + @Default + private @Meta double deform = 0.75D; + + @Value("deform-frequency") + @Default + private @Meta double deformFrequency = 0.1D; + + public boolean doPhysics() { + return physics; + } + + public double getDeform() { + return deform; + } + + public double getDeformFrequency() { + return deformFrequency; + } + + public Range getSize() { + return size; + } + + public BlockState getMaterial() { + return material; + } + + public MaterialSet getReplaceable() { + return replaceable; + } + + public String getID() { + return id; + } + + public Map getMaterialOverrides() { + return materials; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/Ore.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/Ore.java new file mode 100644 index 000000000..640112b46 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/Ore.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore.ores; + +import java.util.Map; +import java.util.Random; + +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.util.vector.Vector3; +import com.dfsek.terra.api.world.Chunk; + + +public abstract class Ore { + + private final BlockState material; + private final MaterialSet replaceable; + private final boolean applyGravity; + private final Map materials; + protected Platform platform; + + public Ore(BlockState material, MaterialSet replaceable, boolean applyGravity, Platform platform, + Map materials) { + this.material = material; + this.replaceable = replaceable; + this.applyGravity = applyGravity; + this.platform = platform; + this.materials = materials; + } + + public abstract void generate(Vector3 origin, Chunk c, Random r); + + public BlockState getMaterial(BlockType replace) { + return materials.getOrDefault(replace, material); + } + + public MaterialSet getReplaceable() { + return replaceable; + } + + public boolean isApplyGravity() { + return applyGravity; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreConfig.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreConfig.java new file mode 100644 index 000000000..ed1aa523b --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreConfig.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore.ores; + +import com.dfsek.terra.api.util.Range; + + +public class OreConfig { + private final Range amount; + private final Range height; + + public OreConfig(Range amount, Range height) { + this.amount = amount; + this.height = height; + } + + public Range getAmount() { + return amount; + } + + public Range getHeight() { + return height; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreHolder.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreHolder.java new file mode 100644 index 000000000..7eb1b89bd --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/OreHolder.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore.ores; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.BiConsumer; + +import com.dfsek.terra.api.util.generic.pair.ImmutablePair; + + +/** + * Holds ordered list of ores mapped to their configs. + */ +public class OreHolder { + private final List entries = new ArrayList<>(); + + public void forEach(BiConsumer> consumer) { + entries.forEach(entry -> consumer.accept(entry.getId(), ImmutablePair.of(entry.getOre(), entry.getConfig()))); + } + + public OreHolder add(Ore ore, OreConfig config, String id) { + entries.add(new Entry(ore, config, id)); + return this; + } + + private static final class Entry { + private final Ore ore; + private final OreConfig config; + private final String id; + + private Entry(Ore ore, OreConfig config, String id) { + this.ore = ore; + this.config = config; + this.id = id; + } + + public OreConfig getConfig() { + return config; + } + + public Ore getOre() { + return ore; + } + + public String getId() { + return id; + } + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java new file mode 100644 index 000000000..32a476738 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore.ores; + +import net.jafama.FastMath; + +import java.util.Map; +import java.util.Random; + +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.util.Range; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.util.vector.Vector3; +import com.dfsek.terra.api.world.Chunk; + + +public class VanillaOre extends Ore { + private final Range sizeRange; + + public VanillaOre(BlockState material, MaterialSet replaceable, boolean applyGravity, Range size, Platform platform, + Map materials) { + super(material, replaceable, applyGravity, platform, materials); + this.sizeRange = size; + } + + @Override + public void generate(Vector3 location, Chunk chunk, Random random) { + double size = sizeRange.get(random); + + int centerX = location.getBlockX(); + int centerZ = location.getBlockZ(); + int centerY = location.getBlockY(); + + + double f = random.nextFloat() * Math.PI; + + double fS = FastMath.sin(f) * size / 8.0F; + double fC = FastMath.cos(f) * size / 8.0F; + + double d1 = centerX + 8 + fS; + double d2 = centerX + 8 - fS; + double d3 = centerZ + 8 + fC; + double d4 = centerZ + 8 - fC; + + double d5 = centerY + random.nextInt(3) - 2D; + double d6 = centerY + random.nextInt(3) - 2D; + + for(int i = 0; i < size; i++) { + double iFactor = i / size; + + double d10 = random.nextDouble() * size / 16.0D; + double d11 = (FastMath.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; + + int xStart = FastMath.roundToInt(FastMath.floor(d1 + (d2 - d1) * iFactor - d11 / 2.0D)); + int yStart = FastMath.roundToInt(FastMath.floor(d5 + (d6 - d5) * iFactor - d11 / 2.0D)); + int zStart = FastMath.roundToInt(FastMath.floor(d3 + (d4 - d3) * iFactor - d11 / 2.0D)); + + int xEnd = FastMath.roundToInt(FastMath.floor(d1 + (d2 - d1) * iFactor + d11 / 2.0D)); + int yEnd = FastMath.roundToInt(FastMath.floor(d5 + (d6 - d5) * iFactor + d11 / 2.0D)); + int zEnd = FastMath.roundToInt(FastMath.floor(d3 + (d4 - d3) * iFactor + d11 / 2.0D)); + + for(int x = xStart; x <= xEnd; x++) { + double d13 = (x + 0.5D - (d1 + (d2 - d1) * iFactor)) / (d11 / 2.0D); + + if(d13 * d13 < 1.0D) { + for(int y = yStart; y <= yEnd; y++) { + double d14 = (y + 0.5D - (d5 + (d6 - d5) * iFactor)) / (d11 / 2.0D); + if(d13 * d13 + d14 * d14 < 1.0D) { + for(int z = zStart; z <= zEnd; z++) { + double d15 = (z + 0.5D - (d3 + (d4 - d3) * iFactor)) / (d11 / 2.0D); + if(x > 15 || z > 15 || y > 255 || x < 0 || z < 0 || y < 0) continue; + + BlockType type = chunk.getBlock(x, y, z).getBlockType(); + if((d13 * d13 + d14 * d14 + d15 * d15 < 1.0D) && getReplaceable().contains(type)) { + chunk.setBlock(x, y, z, getMaterial(type), isApplyGravity()); + } + } + } + } + } + } + } + } +} diff --git a/common/addons/config-ore/src/main/resources/terra.addon.yml b/common/addons/config-ore/src/main/resources/terra.addon.yml new file mode 100644 index 000000000..7f4819b20 --- /dev/null +++ b/common/addons/config-ore/src/main/resources/terra.addon.yml @@ -0,0 +1,12 @@ +schema-version: 1 +contributors: + - Terra contributors +id: config-ore +version: 0.1.0 +entrypoints: + - "com.dfsek.terra.addons.ore.OreAddon" +website: + issues: https://github.com/PolyhedralDev/Terra-config-ore/issues + source: https://github.com/PolyhedralDev/Terra-config-ore + docs: https://github.com/PolyhedralDev/Terra/wiki +license: GNU LGPL v3.0 \ No newline at end of file