From f6828ec5349f492f2c1746f9e8a27f39cf88b284 Mon Sep 17 00:00:00 2001 From: vaylor27 Date: Sun, 10 Sep 2023 14:44:10 -0400 Subject: [PATCH 01/49] allowed the use of M1 chips --- build.gradle | 5 +++-- dumb_library | 2 +- gradle.properties | 2 ++ 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/build.gradle b/build.gradle index 6aa42570..f2cd52ef 100644 --- a/build.gradle +++ b/build.gradle @@ -1,8 +1,8 @@ buildscript { repositories { + mavenCentral() maven { url = 'https://maven.minecraftforge.net' } maven { url = "https://plugins.gradle.org/m2/" } - mavenCentral() } dependencies { classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true @@ -101,7 +101,7 @@ repositories { } } dependencies { - minecraft 'net.minecraftforge:forge:1.16.5-36.2.20' + minecraft 'net.minecraftforge:forge:1.16.5-36.2.34' implementation 'org.projectlombok:lombok:1.18.12' annotationProcessor 'org.projectlombok:lombok:1.18.12' @@ -152,3 +152,4 @@ gradlehook { addField 'payload_json', '{ "embeds": [{ "title":"' + System.getenv("COMMIT_MESSAGE") + " - " + System.getenv("COMMIT_AUTHOR") + '", "timestamp": "{{datetime}}" }] }' addArtifact jar } +apply from: "https://moddingtutorials.org/applesilicon.gradle" \ No newline at end of file diff --git a/dumb_library b/dumb_library index dc5fa004..cb288018 160000 --- a/dumb_library +++ b/dumb_library @@ -1 +1 @@ -Subproject commit dc5fa004681472327150ca134224ec130b35c983 +Subproject commit cb2880189343092bc397a606825b0e20464ea9e9 diff --git a/gradle.properties b/gradle.properties index 784899a6..4f67a6e4 100644 --- a/gradle.properties +++ b/gradle.properties @@ -2,3 +2,5 @@ # This is required to provide enough memory for the Minecraft decompilation process. org.gradle.jvmargs=-Xmx3G org.gradle.daemon=false + +mc_version=1.16.5 \ No newline at end of file From 81941112aab499686f5b5a12a27a68722f21ad73 Mon Sep 17 00:00:00 2001 From: vaylor27 Date: Sat, 16 Sep 2023 01:21:36 -0400 Subject: [PATCH 02/49] add model and block generation for fossils based on a config | add mixin --- build.gradle | 17 +- dumb_library | 2 +- gradle.properties | 2 +- .../ProjectNublarBlockRenderLayers.java | 10 +- .../client/model/fossil/FossilModel.java | 486 ++++++++++++++ .../model/fossil/FossilModelLoader.java | 45 ++ .../client/model/fossil/MatLib.java | 25 + .../mixin/BlockLootTablesInvoker.java | 18 + .../mixin/BlockModelProviderInvoker.java | 31 + .../ReloadableResourceManagerImplMixin.java | 36 + .../projectnublar/server/ProjectNublar.java | 22 +- .../server/block/FossilBlock.java | 6 + .../ProjectNublarFossilOreModelProvider.java | 25 + .../projectnublar/server/fossil/Fossil.java | 23 + .../server/fossil/FossilBlock.java | 11 + .../server/fossil/FossilSerializer.java | 144 ++++ .../projectnublar/server/fossil/Fossils.java | 157 +++++ .../server/fossil/StoneType.java | 46 ++ .../projectnublar/server/fossil/Time.java | 127 ++++ .../fossil/UnSerializedFossilModel.java | 13 + .../server/item/ItemHandler.java | 2 +- .../server/runtimepack/generator/ARRP.java | 33 + .../generator/IdentifierExtension.java | 36 + .../annotations/PreferredEnvironment.java | 21 + .../generator/api/JsonSerializable.java | 30 + .../generator/api/RRPCallbackForge.java | 24 + .../generator/api/RRPPreGenEvent.java | 9 + .../generator/api/RuntimeResourcePack.java | 376 +++++++++++ .../generator/generator/BRRPCubeBlock.java | 80 +++ .../generator/generator/BRRPFenceBlock.java | 97 +++ .../generator/BRRPFenceGateBlock.java | 91 +++ .../generator/generator/BRRPSlabBlock.java | 108 +++ .../generator/generator/BRRPStairsBlock.java | 84 +++ .../generator/generator/BRRPWallBlock.java | 80 +++ .../generator/BlockResourceGenerator.java | 301 +++++++++ .../generator/ItemResourceGenerator.java | 201 ++++++ .../generator/ResourceGeneratorHelper.java | 82 +++ .../generator/generator/TextureRegistry.java | 141 ++++ .../impl/RuntimeResourcePackImpl.java | 632 ++++++++++++++++++ .../generator/json/animation/JAnimation.java | 155 +++++ .../generator/json/animation/JFrame.java | 33 + .../json/blockstate/JBlockModel.java | 148 ++++ .../json/blockstate/JBlockStates.java | 205 ++++++ .../generator/json/blockstate/JMultipart.java | 106 +++ .../generator/json/blockstate/JVariants.java | 357 ++++++++++ .../json/blockstate/JWhenLogical.java | 118 ++++ .../json/blockstate/JWhenProperties.java | 258 +++++++ .../generator/json/lang/JLang.java | 432 ++++++++++++ .../generator/json/loot/JCondition.java | 155 +++++ .../generator/json/loot/JEntry.java | 196 ++++++ .../generator/json/loot/JFunction.java | 145 ++++ .../generator/json/loot/JLootTable.java | 260 +++++++ .../generator/json/loot/JPool.java | 256 +++++++ .../generator/json/models/JDisplay.java | 172 +++++ .../generator/json/models/JElement.java | 143 ++++ .../generator/json/models/JFace.java | 114 ++++ .../generator/json/models/JFaces.java | 137 ++++ .../generator/json/models/JModel.java | 347 ++++++++++ .../generator/json/models/JOverride.java | 64 ++ .../generator/json/models/JPosition.java | 86 +++ .../generator/json/models/JPredicate.java | 68 ++ .../generator/json/models/JRotation.java | 83 +++ .../generator/json/models/JTextures.java | 261 ++++++++ .../generator/json/recipe/JIngredient.java | 312 +++++++++ .../generator/json/recipe/JKeys.java | 149 +++++ .../generator/json/recipe/JPattern.java | 81 +++ .../generator/json/recipe/JRecipe.java | 139 ++++ .../generator/json/recipe/JResult.java | 82 +++ .../generator/json/recipe/JResultRecipe.java | 75 +++ .../generator/json/recipe/JShapedRecipe.java | 101 +++ .../json/recipe/JShapelessRecipe.java | 102 +++ .../generator/json/tags/IdentifiedTag.java | 88 +++ .../runtimepack/generator/json/tags/JTag.java | 319 +++++++++ .../generator/util/CallableFunction.java | 7 + .../generator/util/CountingInputStream.java | 35 + .../util/UnsafeByteArrayOutputStream.java | 48 ++ .../projectnublar/models/block/fossil.obj | 92 +++ .../textures/block/fossil/ammonite.png | Bin 0 -> 4601 bytes .../textures/block/fossil/feather.png | Bin 0 -> 4537 bytes .../textures/block/fossil/feet.png | Bin 0 -> 4538 bytes .../textures/block/fossil/fish.png | Bin 0 -> 4629 bytes .../textures/block/fossil/imprint.png | Bin 0 -> 4638 bytes .../textures/block/fossil/lizard.png | Bin 0 -> 4670 bytes .../textures/block/fossil/tooth.png | Bin 0 -> 4525 bytes .../textures/block/fossil/trilobite.png | Bin 0 -> 4636 bytes src/main/resources/projectnublar.mixins.json | 14 + 86 files changed, 9606 insertions(+), 11 deletions(-) create mode 100755 src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModel.java create mode 100755 src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModelLoader.java create mode 100644 src/main/java/net/dumbcode/projectnublar/client/model/fossil/MatLib.java create mode 100644 src/main/java/net/dumbcode/projectnublar/mixin/BlockLootTablesInvoker.java create mode 100644 src/main/java/net/dumbcode/projectnublar/mixin/BlockModelProviderInvoker.java create mode 100644 src/main/java/net/dumbcode/projectnublar/mixin/ReloadableResourceManagerImplMixin.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/data/ProjectNublarFossilOreModelProvider.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/Fossil.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/FossilBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/FossilSerializer.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/Fossils.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/StoneType.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/Time.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/fossil/UnSerializedFossilModel.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/ARRP.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/IdentifierExtension.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/annotations/PreferredEnvironment.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/api/JsonSerializable.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/api/RRPCallbackForge.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/api/RRPPreGenEvent.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/api/RuntimeResourcePack.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPCubeBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPFenceBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPFenceGateBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPSlabBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPStairsBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BRRPWallBlock.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/BlockResourceGenerator.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/ItemResourceGenerator.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/ResourceGeneratorHelper.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/generator/TextureRegistry.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/impl/RuntimeResourcePackImpl.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/animation/JAnimation.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/animation/JFrame.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JBlockModel.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JBlockStates.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JMultipart.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JVariants.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JWhenLogical.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/blockstate/JWhenProperties.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/lang/JLang.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/loot/JCondition.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/loot/JEntry.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/loot/JFunction.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/loot/JLootTable.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/loot/JPool.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JDisplay.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JElement.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JFace.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JFaces.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JModel.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JOverride.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JPosition.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JPredicate.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JRotation.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/models/JTextures.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JIngredient.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JKeys.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JPattern.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JRecipe.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JResult.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JResultRecipe.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JShapedRecipe.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/recipe/JShapelessRecipe.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/tags/IdentifiedTag.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/json/tags/JTag.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/util/CallableFunction.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/util/CountingInputStream.java create mode 100644 src/main/java/net/dumbcode/projectnublar/server/runtimepack/generator/util/UnsafeByteArrayOutputStream.java create mode 100644 src/main/resources/assets/projectnublar/models/block/fossil.obj create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/ammonite.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/feather.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/feet.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/fish.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/imprint.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/lizard.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/tooth.png create mode 100644 src/main/resources/assets/projectnublar/textures/block/fossil/trilobite.png create mode 100644 src/main/resources/projectnublar.mixins.json diff --git a/build.gradle b/build.gradle index f2cd52ef..3731f36a 100644 --- a/build.gradle +++ b/build.gradle @@ -3,10 +3,12 @@ buildscript { mavenCentral() maven { url = 'https://maven.minecraftforge.net' } maven { url = "https://plugins.gradle.org/m2/" } + maven { url = 'https://repo.spongepowered.org/maven' } } dependencies { classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true classpath "net.dumbcode.gradlehook:GradleHook:2.0.2" + classpath 'org.spongepowered:mixingradle:0.7.+' } } @@ -14,6 +16,7 @@ apply plugin: 'net.minecraftforge.gradle' apply plugin: "net.dumbcode.gradlehook" apply plugin: 'eclipse' apply plugin: 'maven-publish' +apply plugin: 'org.spongepowered.mixin' version = '1.16.5-' + (System.getenv("GITHUB_ACTIONS") ? System.getenv("GITHUB_RUN_NUMBER") : 'dev') group = 'net.dumbcode.projectnublar' // http://maven.apache.org/guides/mini/guide-naming-conventions.html @@ -30,6 +33,10 @@ sourceSets { } } +mixin { + add sourceSets.main, "projectnublar.refmap.json" +} + minecraft { mappings channel: 'official', version: '1.16.5' @@ -44,7 +51,9 @@ minecraft { workingDirectory project.file('run') property 'forge.logging.markers', 'REGISTRIES' property 'forge.logging.console.level', 'debug' - + property 'mixin.env.remapRefMap', 'true' + arg "-mixin.config=projectnublar.mixins.json" + property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg" mods { projectnublar { source sourceSets.main @@ -105,6 +114,7 @@ dependencies { implementation 'org.projectlombok:lombok:1.18.12' annotationProcessor 'org.projectlombok:lombok:1.18.12' + annotationProcessor 'org.spongepowered:mixin:0.8.5:processor' implementation group: 'org.apache.commons', name: 'commons-collections4', version: '4.0' implementation group: 'org.apache.logging.log4j', name: 'log4j-core', version: '2.17.1' @@ -125,7 +135,10 @@ jar { "Implementation-Title": project.name, "Implementation-Version": "${version}", "Implementation-Vendor" :"examplemodsareus", - "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ") + "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"), + "TweakClass": "org.spongepowered.asm.launch.MixinTweaker", + "TweakOrder": 0, + "MixinConfigs": "projectnublar.mixins.json" ]) } } diff --git a/dumb_library b/dumb_library index cb288018..82a9d991 160000 --- a/dumb_library +++ b/dumb_library @@ -1 +1 @@ -Subproject commit cb2880189343092bc397a606825b0e20464ea9e9 +Subproject commit 82a9d9913d082db0b3c97da6f9ac16079bc19ba5 diff --git a/gradle.properties b/gradle.properties index 4f67a6e4..53f20dbb 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -# Sets default memory used for gradle commands. Can be overridden by user or command line properties. +# Sets default memory used for gradle commands. Can be overridden by user or command line BlockStateProperties. # This is required to provide enough memory for the Minecraft decompilation process. org.gradle.jvmargs=-Xmx3G org.gradle.daemon=false diff --git a/src/main/java/net/dumbcode/projectnublar/client/ProjectNublarBlockRenderLayers.java b/src/main/java/net/dumbcode/projectnublar/client/ProjectNublarBlockRenderLayers.java index 99632c78..6efda3c0 100644 --- a/src/main/java/net/dumbcode/projectnublar/client/ProjectNublarBlockRenderLayers.java +++ b/src/main/java/net/dumbcode/projectnublar/client/ProjectNublarBlockRenderLayers.java @@ -7,12 +7,16 @@ import net.dumbcode.projectnublar.server.block.BlockHandler; import net.dumbcode.projectnublar.server.block.FossilBlock; import net.dumbcode.projectnublar.server.dinosaur.Dinosaur; +import net.dumbcode.projectnublar.server.fossil.Fossil; import net.minecraft.block.Block; +import net.dumbcode.projectnublar.server.fossil.Fossils; import net.minecraft.client.renderer.RenderType; +import net.minecraftforge.fml.RegistryObject; import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent; import java.util.Arrays; import java.util.HashSet; +import java.util.List; import java.util.Set; public class ProjectNublarBlockRenderLayers { @@ -23,10 +27,8 @@ public static void setRenderLayers() { setRenderLayers(UNBUILT_INCUBATOR.get(), RenderType.solid(), RenderType.cutout(), RenderType.translucent()); - for (RegistryMap map : FOSSIL.values()) { - for (FossilBlock block : map.values()) { - setRenderLayers(block, RenderType.cutout()); - } + for (RegistryObject block : Fossils.BLOCKS) { + setRenderLayers(block.get(), RenderType.cutout()); } } diff --git a/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModel.java b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModel.java new file mode 100755 index 00000000..61320d29 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModel.java @@ -0,0 +1,486 @@ +/* + * Minecraft Forge + * Copyright (c) 2016-2021. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation version 2.1 + * of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package net.dumbcode.projectnublar.client.model.fossil; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import joptsimple.internal.Strings; +import net.minecraft.client.renderer.model.*; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.VertexFormatElement; +import net.minecraft.util.Direction; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.math.vector.TransformationMatrix; +import net.minecraft.util.math.vector.Vector2f; +import net.minecraft.util.math.vector.Vector3f; +import net.minecraft.util.math.vector.Vector4f; +import net.minecraftforge.client.model.*; +import net.minecraftforge.client.model.geometry.IModelGeometryPart; +import net.minecraftforge.client.model.geometry.IMultipartModelGeometry; +import net.minecraftforge.client.model.obj.LineReader; +import net.minecraftforge.client.model.obj.MaterialLibrary; +import net.minecraftforge.client.model.obj.OBJModel; +import net.minecraftforge.client.model.pipeline.BakedQuadBuilder; +import net.minecraftforge.client.model.pipeline.IVertexConsumer; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.MutablePair; +import org.apache.commons.lang3.tuple.Pair; + +import javax.annotation.Nullable; +import java.io.IOException; +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +//TODO: make the item models display an overlay +public class FossilModel implements IMultipartModelGeometry { + private static final Vector4f COLOR_WHITE = new Vector4f(1, 1, 1, 1); + private static final Vector2f[] DEFAULT_COORDS = { + new Vector2f(0, 0), + new Vector2f(0, 1), + new Vector2f(1, 1), + new Vector2f(1, 0), + }; + + private final Map parts = Maps.newHashMap(); + + private final List positions = Lists.newArrayList(); + private final List texCoords = Lists.newArrayList(); + private final List normals = Lists.newArrayList(); + private final List colors = Lists.newArrayList(); + + public final boolean detectCullableFaces; + public final boolean diffuseLighting; + public final boolean flipV; + public final boolean ambientToFullbright; + + public final ResourceLocation modelLocation; + public final ResourceLocation particle; + + + public FossilModel(LineReader reader, OBJModel.ModelSettings settings, ResourceLocation stoneTexture, ResourceLocation fossilTexture, int tint, ResourceLocation particle) throws IOException { + this.modelLocation = settings.modelLocation; + this.detectCullableFaces = settings.detectCullableFaces; + this.diffuseLighting = settings.diffuseLighting; + this.flipV = settings.flipV; + this.ambientToFullbright = settings.ambientToFullbright; + this.particle = particle; + + MatLib mtllib = new MatLib(); + MaterialLibrary.Material currentMat = null; + String currentSmoothingGroup = null; + ModelGroup currentGroup = null; + ModelObject currentObject = null; + ModelMesh currentMesh = null; + + boolean objAboveGroup = false; + + Map matMap = new HashMap<>(); + MaterialLibrary.Material stone = new MaterialLibrary.Material("stone"); + stone.diffuseColorMap = stoneTexture.toString(); + stone.diffuseTintIndex = 1; + stone.dissolve = 0; + matMap.put("stone", stone); + + MaterialLibrary.Material fossil = new MaterialLibrary.Material("fossil"); + fossil.diffuseColorMap = fossilTexture.toString(); + fossil.diffuseTintIndex = 2; + fossil.diffuseColor = new Vector4f((tint >> 16) & 0xff, (tint >> 8) & 0xff, (tint) & 0xff, (tint >> 24) & 0xff); + stone.dissolve = 0; + matMap.put("fossil", fossil); + mtllib.setMaterials(matMap); + + String[] line; + while ((line = reader.readAndSplitLine(true)) != null) { + switch (line[0]) { + case "usemtl": // Sets the current material (starts new mesh) + { + String mat = Strings.join(Arrays.copyOfRange(line, 1, line.length), " "); + MaterialLibrary.Material newMat = mtllib.getMaterial(mat); + if (!Objects.equals(newMat, currentMat)) { + currentMat = newMat; + if (currentMesh != null && currentMesh.mat == null && currentMesh.faces.isEmpty()) { + currentMesh.mat = currentMat; + } else { + // Start new mesh + currentMesh = null; + } + } + break; + } + + case "v": // Vertex + positions.add(OBJModel.parseVector4To3(line)); + break; + case "vt": // Vertex texcoord + texCoords.add(OBJModel.parseVector2(line)); + break; + case "vn": // Vertex normal + normals.add(OBJModel.parseVector3(line)); + break; + case "vc": // Vertex color (non-standard) + colors.add(OBJModel.parseVector4(line)); + break; + + case "f": // Face + { + if (currentMesh == null) { + currentMesh = new ModelMesh(currentMat, currentSmoothingGroup); + if (currentObject != null) { + currentObject.meshes.add(currentMesh); + } else { + if (currentGroup == null) { + currentGroup = new ModelGroup(""); + parts.put("", currentGroup); + } + currentGroup.meshes.add(currentMesh); + } + } + + int[][] vertices = new int[line.length - 1][]; + for (int i = 0; i < vertices.length; i++) { + String vertexData = line[i + 1]; + String[] vertexParts = vertexData.split("/"); + int[] vertex = Arrays.stream(vertexParts).mapToInt(num -> Strings.isNullOrEmpty(num) ? 0 : Integer.parseInt(num)).toArray(); + if (vertex[0] < 0) vertex[0] = positions.size() + vertex[0]; + else vertex[0]--; + if (vertex.length > 1) { + if (vertex[1] < 0) vertex[1] = texCoords.size() + vertex[1]; + else vertex[1]--; + if (vertex.length > 2) { + if (vertex[2] < 0) vertex[2] = normals.size() + vertex[2]; + else vertex[2]--; + if (vertex.length > 3) { + if (vertex[3] < 0) vertex[3] = colors.size() + vertex[3]; + else vertex[3]--; + } + } + } + vertices[i] = vertex; + } + + currentMesh.faces.add(vertices); + + break; + } + + case "s": // Smoothing group (starts new mesh) + { + String smoothingGroup = "off".equals(line[1]) ? null : line[1]; + if (!Objects.equals(currentSmoothingGroup, smoothingGroup)) { + currentSmoothingGroup = smoothingGroup; + if (currentMesh != null && currentMesh.smoothingGroup == null && currentMesh.faces.isEmpty()) { + currentMesh.smoothingGroup = currentSmoothingGroup; + } else { + // Start new mesh + currentMesh = null; + } + } + break; + } + + case "g": { + String name = line[1]; + if (objAboveGroup) { + currentObject = new ModelObject(currentGroup.name() + "/" + name); + currentGroup.parts.put(name, currentObject); + } else { + currentGroup = new ModelGroup(name); + parts.put(name, currentGroup); + currentObject = null; + } + // Start new mesh + currentMesh = null; + break; + } + + case "o": { + String name = line[1]; + if (objAboveGroup || currentGroup == null) { + objAboveGroup = true; + + currentGroup = new ModelGroup(name); + parts.put(name, currentGroup); + currentObject = null; + } else { + currentObject = new ModelObject(currentGroup.name() + "/" + name); + currentGroup.parts.put(name, currentObject); + } + // Start new mesh + currentMesh = null; + break; + } + } + } + } + + @Override + public Collection getParts() { + return parts.values(); + } + + @Override + public Optional getPart(String name) { + return Optional.ofNullable(parts.get(name)); + } + + private Pair makeQuad(int[][] indices, int tintIndex, Vector4f colorTint, Vector4f ambientColor, TextureAtlasSprite texture, TransformationMatrix transform) { + boolean needsNormalRecalculation = false; + for (int[] ints : indices) { + needsNormalRecalculation |= ints.length < 3; + } + Vector3f faceNormal = new Vector3f(0, 0, 0); + if (needsNormalRecalculation) { + Vector3f a = positions.get(indices[0][0]); + Vector3f ab = positions.get(indices[1][0]); + Vector3f ac = positions.get(indices[2][0]); + Vector3f abs = ab.copy(); + abs.sub(a); + Vector3f acs = ac.copy(); + acs.sub(a); + abs.cross(acs); + abs.normalize(); + faceNormal = abs; + } + + Vector4f[] pos = new Vector4f[4]; + Vector3f[] norm = new Vector3f[4]; + + BakedQuadBuilder builder = new BakedQuadBuilder(texture); + + builder.setQuadTint(tintIndex); + + Vector2f uv2 = new Vector2f(0, 0); + if (ambientToFullbright) { + int fakeLight = (int) ((ambientColor.x() + ambientColor.y() + ambientColor.z()) * 15 / 3.0f); + uv2 = new Vector2f((fakeLight << 4) / 32767.0f, (fakeLight << 4) / 32767.0f); + builder.setApplyDiffuseLighting(fakeLight == 0); + } else { + builder.setApplyDiffuseLighting(diffuseLighting); + } + + boolean hasTransform = !transform.isIdentity(); + // The incoming transform is referenced on the center of the block, but our coords are referenced on the corner + + for (int i = 0; i < 4; i++) { + int[] index = indices[Math.min(i, indices.length - 1)]; + Vector3f pos0 = positions.get(index[0]); + Vector4f position = new Vector4f(pos0); + Vector2f texCoord = index.length >= 2 && !texCoords.isEmpty() ? texCoords.get(index[1]) : DEFAULT_COORDS[i]; + Vector3f norm0 = !needsNormalRecalculation && index.length >= 3 && !normals.isEmpty() ? normals.get(index[2]) : faceNormal; + Vector3f normal = norm0; + Vector4f color = index.length >= 4 && !colors.isEmpty() ? colors.get(index[3]) : COLOR_WHITE; + if (hasTransform) { + normal = norm0.copy(); + transform.transformPosition(position); + transform.transformNormal(normal); + } + ; + Vector4f tintedColor = new Vector4f( + color.x() * colorTint.x(), + color.y() * colorTint.y(), + color.z() * colorTint.z(), + color.w() * colorTint.w()); + float u = texture.getU(texCoord.x * 16); + float v = texture.getV((flipV ? (1 - texCoord.y) : texCoord.y) * 16); + putVertexData(builder, position, texCoord, normal, tintedColor, uv2, texture); + pos[i] = position; + norm[i] = normal; + } + + builder.setQuadOrientation(Direction.getNearest(norm[0].x(), norm[0].y(), norm[0].z())); + + Direction cull = null; + if (detectCullableFaces) { + if (MathHelper.equal(pos[0].x(), 0) && // vertex.position.x + MathHelper.equal(pos[1].x(), 0) && + MathHelper.equal(pos[2].x(), 0) && + MathHelper.equal(pos[3].x(), 0) && + norm[0].x() < 0) // vertex.normal.x + { + cull = Direction.WEST; + } else if (MathHelper.equal(pos[0].x(), 1) && // vertex.position.x + MathHelper.equal(pos[1].x(), 1) && + MathHelper.equal(pos[2].x(), 1) && + MathHelper.equal(pos[3].x(), 1) && + norm[0].x() > 0) // vertex.normal.x + { + cull = Direction.EAST; + } else if (MathHelper.equal(pos[0].z(), 0) && // vertex.position.z + MathHelper.equal(pos[1].z(), 0) && + MathHelper.equal(pos[2].z(), 0) && + MathHelper.equal(pos[3].z(), 0) && + norm[0].z() < 0) // vertex.normal.z + { + cull = Direction.NORTH; // can never remember + } else if (MathHelper.equal(pos[0].z(), 1) && // vertex.position.z + MathHelper.equal(pos[1].z(), 1) && + MathHelper.equal(pos[2].z(), 1) && + MathHelper.equal(pos[3].z(), 1) && + norm[0].z() > 0) // vertex.normal.z + { + cull = Direction.SOUTH; + } else if (MathHelper.equal(pos[0].y(), 0) && // vertex.position.y + MathHelper.equal(pos[1].y(), 0) && + MathHelper.equal(pos[2].y(), 0) && + MathHelper.equal(pos[3].y(), 0) && + norm[0].y() < 0) // vertex.normal.z + { + cull = Direction.DOWN; // can never remember + } else if (MathHelper.equal(pos[0].y(), 1) && // vertex.position.y + MathHelper.equal(pos[1].y(), 1) && + MathHelper.equal(pos[2].y(), 1) && + MathHelper.equal(pos[3].y(), 1) && + norm[0].y() > 0) // vertex.normal.y + { + cull = Direction.UP; + } + } + + return Pair.of(builder.build(), cull); + } + + private void putVertexData(IVertexConsumer consumer, Vector4f position0, Vector2f texCoord0, Vector3f normal0, Vector4f color0, Vector2f uv2, TextureAtlasSprite texture) { + ImmutableList elements = consumer.getVertexFormat().getElements(); + for (int j = 0; j < elements.size(); j++) { + VertexFormatElement e = elements.get(j); + switch (e.getUsage()) { + case POSITION: + consumer.put(j, position0.x(), position0.y(), position0.z(), position0.w()); + break; + case COLOR: + consumer.put(j, color0.x(), color0.y(), color0.z(), color0.w()); + break; + case UV: + switch (e.getIndex()) { + case 0: + consumer.put(j, + texture.getU(texCoord0.x * 16), + texture.getV((flipV ? (1 - texCoord0.y) : texCoord0.y) * 16) + ); + break; + case 2: + consumer.put(j, uv2.x, uv2.y); + break; + default: + consumer.put(j); + break; + } + break; + case NORMAL: + consumer.put(j, normal0.x(), normal0.y(), normal0.z()); + break; + default: + consumer.put(j); + break; + } + } + } + + public class ModelObject implements IModelGeometryPart { + public final String name; + + List meshes = Lists.newArrayList(); + + ModelObject(String name) { + this.name = name; + } + + @Override + public String name() { + return name; + } + + @Override + public void addQuads(IModelConfiguration owner, IModelBuilder modelBuilder, ModelBakery bakery, Function spriteGetter, IModelTransform modelTransform, ResourceLocation modelLocation) { + for (ModelMesh mesh : meshes) { + MaterialLibrary.Material mat = mesh.mat; + if (mat == null) + continue; + TextureAtlasSprite texture = spriteGetter.apply(ModelLoaderRegistry.resolveTexture(mat.diffuseColorMap, owner)); + int tintIndex = mat.diffuseTintIndex; + Vector4f colorTint = mat.diffuseColor; + + for (int[][] face : mesh.faces) { + Pair quad = makeQuad(face, tintIndex, colorTint, mat.ambientColor, texture, modelTransform.getRotation()); + if (quad != null) { + if (quad.getRight() == null) + modelBuilder.addGeneralQuad(quad.getLeft()); + else + modelBuilder.addFaceQuad(quad.getRight(), quad.getLeft()); + } + } + } + } + + @Override + public Collection getTextures(IModelConfiguration owner, Function modelGetter, Set> missingTextureErrors) { + Collection materials = meshes.stream().map(mesh -> { + assert mesh.mat != null; + return ModelLoaderRegistry.resolveTexture(mesh.mat.diffuseColorMap, owner); + }).collect(Collectors.toSet()); + materials.add(ModelLoaderRegistry.resolveTexture(particle.toString(), owner)); + return materials; + } + } + + public class ModelGroup extends ModelObject { + final Map parts = Maps.newHashMap(); + + ModelGroup(String name) { + super(name); + } + + public Collection getParts() { + return parts.values(); + } + + @Override + public void addQuads(IModelConfiguration owner, IModelBuilder modelBuilder, ModelBakery bakery, Function spriteGetter, IModelTransform modelTransform, ResourceLocation modelLocation) { + super.addQuads(owner, modelBuilder, bakery, spriteGetter, modelTransform, modelLocation); + + getParts().stream().filter(owner::getPartVisibility) + .forEach(part -> part.addQuads(owner, modelBuilder, bakery, spriteGetter, modelTransform, modelLocation)); + } + + @Override + public Collection getTextures(IModelConfiguration owner, Function modelGetter, Set> missingTextureErrors) { + Set combined = Sets.newHashSet(); + combined.addAll(super.getTextures(owner, modelGetter, missingTextureErrors)); + for (IModelGeometryPart part : getParts()) + combined.addAll(part.getTextures(owner, modelGetter, missingTextureErrors)); + return combined; + } + } + + public static class ModelMesh { + public MaterialLibrary.Material mat; + public String smoothingGroup; + public final List faces = Lists.newArrayList(); + + public ModelMesh(MaterialLibrary.Material currentMat, String currentSmoothingGroup) { + this.mat = currentMat; + this.smoothingGroup = currentSmoothingGroup; + } + } +} \ No newline at end of file diff --git a/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModelLoader.java b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModelLoader.java new file mode 100755 index 00000000..6b0afb2b --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/FossilModelLoader.java @@ -0,0 +1,45 @@ +package net.dumbcode.projectnublar.client.model.fossil; + +import com.google.gson.JsonDeserializationContext; +import com.google.gson.JsonObject; +import net.dumbcode.projectnublar.server.ProjectNublar; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.IResourceManager; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.client.model.IModelLoader; +import net.minecraftforge.client.model.obj.LineReader; +import net.minecraftforge.client.model.obj.OBJModel; + +public enum FossilModelLoader implements IModelLoader { + INSTANCE; + + @Override + public void onResourceManagerReload(IResourceManager resourceManager) { + } + + @Override + public FossilModel read(JsonDeserializationContext deserializationContext, JsonObject modelContents) { + ResourceLocation stoneLocation = new ResourceLocation(""); + ResourceLocation fossilLocation = new ResourceLocation(""); + ResourceLocation particle = new ResourceLocation(""); + int tint = 0; + if (modelContents.has("stone")) { + stoneLocation = new ResourceLocation(modelContents.get("stone").getAsString()); + } + if (modelContents.has("fossil")) { + fossilLocation = new ResourceLocation(modelContents.get("fossil").getAsString()); + } + if (modelContents.has("tint")) { + tint = modelContents.get("tint").getAsInt(); + } + if (modelContents.has("particle")) { + particle = new ResourceLocation(modelContents.get("particle").getAsString()); + } + ResourceLocation modeLocation = new ResourceLocation(ProjectNublar.MODID, "models/block/fossil.obj"); + try(LineReader reader = new LineReader(Minecraft.getInstance().getResourceManager().getResource(modeLocation))) { + return new FossilModel(reader, new OBJModel.ModelSettings(modeLocation, false, true, false, false, null), stoneLocation, fossilLocation, tint, particle); + } catch (Exception e) { + throw new IllegalStateException(e); + } + } +} \ No newline at end of file diff --git a/src/main/java/net/dumbcode/projectnublar/client/model/fossil/MatLib.java b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/MatLib.java new file mode 100644 index 00000000..e196e580 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/client/model/fossil/MatLib.java @@ -0,0 +1,25 @@ +package net.dumbcode.projectnublar.client.model.fossil; + +import com.google.common.collect.Maps; +import lombok.Getter; +import lombok.Setter; +import net.minecraftforge.client.model.obj.MaterialLibrary; + +import java.util.Map; +import java.util.NoSuchElementException; + +public class MatLib { + public Map materials = Maps.newHashMap(); + + + public MaterialLibrary.Material getMaterial(String mat) + { + if (!materials.containsKey(mat)) + throw new NoSuchElementException("The material was not found in the library: " + mat); + return materials.get(mat); + } + + public void setMaterials(Map materials) { + this.materials = materials; + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/mixin/BlockLootTablesInvoker.java b/src/main/java/net/dumbcode/projectnublar/mixin/BlockLootTablesInvoker.java new file mode 100644 index 00000000..0c6a72b5 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/mixin/BlockLootTablesInvoker.java @@ -0,0 +1,18 @@ +package net.dumbcode.projectnublar.mixin; + +import net.minecraft.block.Block; +import net.minecraft.data.BlockModelProvider; +import net.minecraft.data.IFinishedBlockState; +import net.minecraft.data.loot.BlockLootTables; +import net.minecraft.loot.LootTable; +import net.minecraft.util.ResourceLocation; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +@Mixin(BlockLootTables.class) +public class BlockLootTablesInvoker { + @Invoker("createSlabItemTable") + public static LootTable.Builder createSlabItemTable(Block block) { + throw new AssertionError(); + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/mixin/BlockModelProviderInvoker.java b/src/main/java/net/dumbcode/projectnublar/mixin/BlockModelProviderInvoker.java new file mode 100644 index 00000000..62909026 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/mixin/BlockModelProviderInvoker.java @@ -0,0 +1,31 @@ +package net.dumbcode.projectnublar.mixin; + +import net.minecraft.block.Block; +import net.minecraft.data.BlockModelProvider; +import net.minecraft.data.IFinishedBlockState; +import net.minecraft.util.ResourceLocation; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +@Mixin(BlockModelProvider.class) +public class BlockModelProviderInvoker { + @Invoker("createFence") + public static IFinishedBlockState createFence(Block block, ResourceLocation resourceLocation, ResourceLocation resourceLocation1) { + throw new AssertionError(); + } + + @Invoker("createFenceGate") + public static IFinishedBlockState createFenceGate(Block block, ResourceLocation resourceLocation, ResourceLocation resourceLocation1, ResourceLocation resourceLocation2, ResourceLocation resourceLocation3) { + throw new AssertionError(); + } + + @Invoker("createStairs") + public static IFinishedBlockState createStairs(Block block, ResourceLocation resourceLocation, ResourceLocation resourceLocation1, ResourceLocation resourceLocation2) { + throw new AssertionError(); + } + + @Invoker("createWall") + public static IFinishedBlockState createWall(Block block, ResourceLocation resourceLocation, ResourceLocation resourceLocation1, ResourceLocation resourceLocation2) { + throw new AssertionError(); + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/mixin/ReloadableResourceManagerImplMixin.java b/src/main/java/net/dumbcode/projectnublar/mixin/ReloadableResourceManagerImplMixin.java new file mode 100644 index 00000000..c5569ea4 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/mixin/ReloadableResourceManagerImplMixin.java @@ -0,0 +1,36 @@ +package net.dumbcode.projectnublar.mixin; + +import net.dumbcode.projectnublar.server.runtimepack.generator.api.RRPCallbackForge; +import net.minecraft.resources.IResourcePack; +import net.minecraft.resources.ResourcePackType; +import net.minecraft.resources.SimpleReloadableResourceManager; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.ModifyVariable; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.ExecutionException; + +@Mixin(SimpleReloadableResourceManager.class) +public abstract class ReloadableResourceManagerImplMixin { + @Shadow + @Final + private ResourcePackType type; + + @ModifyVariable(method = "createFullReload", + at = @At(value = "HEAD"), + argsOnly = true) + private List registerARRPs(List packs) throws ExecutionException, InterruptedException { + List before = new ArrayList<>(); + RRPCallbackForge.BEFORE_VANILLA.build().stream().map(f -> f.apply(type)).filter(Objects::nonNull).forEach(before::add); + before.addAll(packs); + RRPCallbackForge.AFTER_VANILLA.build().stream().map(f -> f.apply(type)).filter(Objects::nonNull).forEach(before::add); + return before; + } +} \ No newline at end of file diff --git a/src/main/java/net/dumbcode/projectnublar/server/ProjectNublar.java b/src/main/java/net/dumbcode/projectnublar/server/ProjectNublar.java index 75f212c0..f36a913d 100644 --- a/src/main/java/net/dumbcode/projectnublar/server/ProjectNublar.java +++ b/src/main/java/net/dumbcode/projectnublar/server/ProjectNublar.java @@ -12,6 +12,7 @@ import net.dumbcode.projectnublar.client.DinoItemResourcePack; import net.dumbcode.projectnublar.client.ProjectNublarBlockRenderLayers; import net.dumbcode.projectnublar.client.gui.icons.EnumWeatherIcons; +import net.dumbcode.projectnublar.client.model.fossil.FossilModelLoader; import net.dumbcode.projectnublar.client.particle.ProjectNublarParticleFactories; import net.dumbcode.projectnublar.client.render.blockentity.BlockEntityEggPrinterRenderer; import net.dumbcode.projectnublar.client.render.blockentity.BlockEntityIncubatorRenderer; @@ -25,6 +26,7 @@ import net.dumbcode.projectnublar.server.command.DinosaurArgument; import net.dumbcode.projectnublar.server.containers.ProjectNublarContainers; import net.dumbcode.projectnublar.server.data.ProjectNublarBlockTagsProvider; +import net.dumbcode.projectnublar.server.data.ProjectNublarFossilOreModelProvider; import net.dumbcode.projectnublar.server.data.ProjectNublarRecipeProvider; import net.dumbcode.projectnublar.server.dinosaur.Dinosaur; import net.dumbcode.projectnublar.server.dinosaur.DinosaurHandler; @@ -35,6 +37,7 @@ import net.dumbcode.projectnublar.server.entity.DataSerializerHandler; import net.dumbcode.projectnublar.server.entity.EntityHandler; import net.dumbcode.projectnublar.server.entity.system.impl.*; +import net.dumbcode.projectnublar.server.fossil.Fossils; import net.dumbcode.projectnublar.server.item.EmptySyringeItemHandler; import net.dumbcode.projectnublar.server.item.ItemHandler; import net.dumbcode.projectnublar.server.network.*; @@ -59,6 +62,9 @@ import net.minecraft.util.ResourceLocation; import net.minecraft.util.text.TranslationTextComponent; import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.client.event.ModelRegistryEvent; +import net.minecraftforge.client.model.ModelLoader; +import net.minecraftforge.client.model.ModelLoaderRegistry; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.data.ExistingFileHelper; import net.minecraftforge.event.RegisterCommandsEvent; @@ -87,8 +93,7 @@ import java.io.File; import java.io.FileWriter; import java.io.IOException; -import java.util.ArrayList; -import java.util.List; +import java.nio.file.Paths; import java.util.Map; import java.util.function.Consumer; import java.util.function.Predicate; @@ -132,6 +137,7 @@ public ProjectNublar() { SoundHandler.REGISTER.register(bus); GeneticHandler.REGISTER.register(bus); DinosaurHandler.REGISTER.register(bus); + Fossils.FOSSIL_BLOCKS.register(bus); PlantHandler.REGISTER.register(bus); ProjectNublarRecipesSerializers.REGISTER.register(bus); ComponentHandler.REGISTER.register(bus); @@ -167,7 +173,17 @@ public void clientSetup() { BlockEntityIncubatorRenderer.markResolvers(); + Fossils.addBuiltInFossilsAndTypes(); + Fossils.generateFossils(); + Fossils.PACK.dump(Paths.get("fossil/")); + } + @Mod.EventBusSubscriber(modid = MODID, bus = Mod.EventBusSubscriber.Bus.MOD) + public static class ModelRegistryEvents { + @SubscribeEvent + public static void onModelsRegistered(ModelRegistryEvent event) { + ModelLoaderRegistry.registerLoader(new ResourceLocation(MODID, "fossil"), FossilModelLoader.INSTANCE); + } } public void registerCommands(RegisterCommandsEvent event) { @@ -181,6 +197,7 @@ public void gatherData(GatherDataEvent event) { if (event.includeServer()) { gen.addProvider(new ProjectNublarBlockTagsProvider(gen, helper)); gen.addProvider(new ProjectNublarRecipeProvider(gen)); + gen.addProvider(new ProjectNublarFossilOreModelProvider(gen, helper)); } } @@ -189,6 +206,7 @@ public void clientPreInit(FMLClientSetupEvent event) { IResourceManager manager = Minecraft.getInstance().getResourceManager(); ((SimpleReloadableResourceManager)manager).add(new DinoItemResourcePack()); + ((SimpleReloadableResourceManager)manager).add(Fossils.PACK); ProjectNublarBlockRenderLayers.setRenderLayers(); diff --git a/src/main/java/net/dumbcode/projectnublar/server/block/FossilBlock.java b/src/main/java/net/dumbcode/projectnublar/server/block/FossilBlock.java index c6672b16..b0058674 100644 --- a/src/main/java/net/dumbcode/projectnublar/server/block/FossilBlock.java +++ b/src/main/java/net/dumbcode/projectnublar/server/block/FossilBlock.java @@ -12,6 +12,12 @@ import net.minecraft.block.material.MaterialColor; //TODO: move to a simple classs + +/** + * For removal soon + * wtf is this, obsolete with the new system + */ +@Deprecated public class FossilBlock extends Block implements IItemBlock { @Getter private final Dinosaur dinosaur; diff --git a/src/main/java/net/dumbcode/projectnublar/server/data/ProjectNublarFossilOreModelProvider.java b/src/main/java/net/dumbcode/projectnublar/server/data/ProjectNublarFossilOreModelProvider.java new file mode 100644 index 00000000..c3b0d6a1 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/data/ProjectNublarFossilOreModelProvider.java @@ -0,0 +1,25 @@ +package net.dumbcode.projectnublar.server.data; + +import net.dumbcode.projectnublar.server.ProjectNublar; +import net.dumbcode.projectnublar.server.recipes.crafting.ProjectNublarRecipesSerializers; +import net.minecraft.data.CustomRecipeBuilder; +import net.minecraft.data.DataGenerator; +import net.minecraft.data.IFinishedRecipe; +import net.minecraft.data.RecipeProvider; +import net.minecraftforge.client.model.generators.BlockModelProvider; +import net.minecraftforge.client.model.generators.BlockStateProvider; +import net.minecraftforge.client.model.generators.ModelProvider; +import net.minecraftforge.common.data.ExistingFileHelper; + +import java.util.function.Consumer; + +public class ProjectNublarFossilOreModelProvider extends BlockStateProvider { + public ProjectNublarFossilOreModelProvider(DataGenerator generator, ExistingFileHelper helper) { + super(generator, ProjectNublar.MODID, helper); + } + + @Override + protected void registerStatesAndModels() { + + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossil.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossil.java new file mode 100644 index 00000000..d6c72628 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossil.java @@ -0,0 +1,23 @@ +package net.dumbcode.projectnublar.server.fossil; + +import net.minecraft.util.ResourceLocation; + +import javax.annotation.Nullable; +import java.util.List; + +public class Fossil { + double timeStart; + double timeEnd; + @Nullable + List stoneTypes; + ResourceLocation texture; + String name; + + public Fossil(double timeStart, double timeEnd, List stoneTypes, ResourceLocation texture, String name) { + this.timeStart = timeStart; + this.timeEnd = timeEnd; + this.stoneTypes = stoneTypes; + this.texture = texture; + this.name = name; + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilBlock.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilBlock.java new file mode 100644 index 00000000..eeaeb0e4 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilBlock.java @@ -0,0 +1,11 @@ +package net.dumbcode.projectnublar.server.fossil; + +import net.dumbcode.projectnublar.server.block.IItemBlock; +import net.minecraft.block.Block; +import net.minecraftforge.items.IItemHandler; + +public class FossilBlock extends Block implements IItemBlock { + public FossilBlock(Properties p_i48440_1_) { + super(p_i48440_1_); + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilSerializer.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilSerializer.java new file mode 100644 index 00000000..3f5974b1 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/FossilSerializer.java @@ -0,0 +1,144 @@ +package net.dumbcode.projectnublar.server.fossil; + +import com.google.common.collect.ImmutableMultimap; +import com.google.common.collect.Multimap; +import com.google.common.collect.Multiset; +import com.google.gson.*; +import com.mojang.datafixers.util.Pair; +import net.dumbcode.projectnublar.server.ProjectNublar; +import net.dumbcode.projectnublar.server.runtimepack.generator.json.tags.JTag; +import net.minecraft.util.ResourceLocation; +import org.apache.commons.io.output.ByteArrayOutputStream; + +import java.io.*; +import java.nio.charset.StandardCharsets; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +public class FossilSerializer { + public static byte[] serialize(UnSerializedFossilModel object) { + Gson gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8); + gson.toJson(serialize(object, true), writer); + try { + writer.close(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + return stream.toByteArray(); + } + + public static byte[] serialize(String id) { + System.out.println("w"); + Gson gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8); + JsonObject object = new JsonObject(); + JsonObject variants = new JsonObject(); + JsonObject none = new JsonObject(); + none.addProperty("model", id); + variants.add("", none); + object.add("variants", variants); + gson.toJson(object, writer); + try { + writer.close(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + System.out.println("m"); + return stream.toByteArray(); + } + + public static byte[] serialize(ResourceLocation id) { + Gson gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8); + JsonObject object = new JsonObject(); + object.addProperty("parent", "projectnublar:block/" + id.getPath()); + gson.toJson(object, writer); + try { + writer.close(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + return stream.toByteArray(); + } + + public static JsonObject serialize(UnSerializedFossilModel src, boolean a) { + System.out.println("q"); + JsonObject object = new JsonObject(); + object.addProperty("loader", ProjectNublar.MODID + ":fossil"); + object.addProperty("parent", "block/cube"); + JsonObject particle = new JsonObject(); + particle.addProperty("particle", src.stoneTexture); + object.add("textures", particle); + object.addProperty("stone", src.stoneTexture); + object.addProperty("fossil", src.fossilTexture); + object.addProperty("tint", src.tint); + System.out.println("b"); + return object; + } + + public static byte[] serialize() { + System.out.println("n"); + Gson gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8); + + JsonObject object = new JsonObject(); + JsonObject pack = new JsonObject(); + pack.addProperty("description", "Auto-Generated Fossil pack for ProjectNublar"); + pack.addProperty("pack_format", 6); + object.add("pack", pack); + gson.toJson(object, writer); + + try { + writer.close(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + System.out.println("p"); + return stream.toByteArray(); + } + + + public static void serialize(Multimap fossils) { + System.out.println("rgesdg"); + ImmutableMultimap.Builder>> tagsBuilder = new ImmutableMultimap.Builder<>(); + for (StoneType type : fossils.keys()) { + tagsBuilder.put(type.mineableBy, new Pair<>(type, fossils.get(type))); + } + Multimap>> tags = tagsBuilder.build(); + for (String key : tags.keys()) { + Gson gson = new GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create(); + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + OutputStreamWriter writer = new OutputStreamWriter(stream, StandardCharsets.UTF_8); + + JsonObject object = new JsonObject(); + object.addProperty("replace", false); + JsonArray values = new JsonArray(); + for (Pair> type : tags.get(key)) { + for (Fossil fossil : type.getSecond()) { + values.add(type.getFirst().name.replace(" ", "_").toLowerCase() + "_" + fossil.name.replace(" ", "_").toLowerCase()); + } + } + object.add("values", values); + gson.toJson(object, writer); + + try { + writer.close(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + Fossils.PACK.addData(new ResourceLocation("tags/blocks/" + key + ".json"), stream.toByteArray()); + } + System.out.println("wrtwgg"); + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossils.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossils.java new file mode 100644 index 00000000..4aefbec2 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/Fossils.java @@ -0,0 +1,157 @@ +package net.dumbcode.projectnublar.server.fossil; + +import com.google.common.collect.ImmutableMultimap; +import com.google.common.collect.Multimap; +import net.dumbcode.projectnublar.server.ProjectNublar; +import net.dumbcode.projectnublar.server.block.IItemBlock; +import net.dumbcode.projectnublar.server.item.ItemHandler; +import net.dumbcode.projectnublar.server.runtimepack.generator.api.RuntimeResourcePack; +import net.dumbcode.projectnublar.server.runtimepack.generator.json.lang.JLang; +import net.minecraft.block.AbstractBlock; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.item.Item; +import net.minecraft.resources.IResourcePack; +import net.minecraft.resources.ResourcePackType; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fml.RegistryObject; +import net.minecraftforge.registries.DeferredRegister; +import net.minecraftforge.registries.ForgeRegistries; +import org.apache.commons.lang3.text.WordUtils; + +import java.util.*; +import java.util.function.Supplier; + +import static net.dumbcode.projectnublar.server.runtimepack.generator.impl.RuntimeResourcePackImpl.fix; + +public class Fossils { + public static final RuntimeResourcePack PACK = RuntimeResourcePack.create(new ResourceLocation(ProjectNublar.MODID, "fossil")); + public static final List FOSSILS = new ArrayList<>(); + public static final List> BLOCKS = new ArrayList<>(); + public static final List> ITEMS = new ArrayList<>(); + public static final List STONE_TYPES = new ArrayList<>(); + public static final DeferredRegister FOSSIL_BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, ProjectNublar.MODID); + + private static Multimap FOSSILS_GENNED; + public static void generateFossils() { + System.out.println("u"); + generateAllFossilsAndStoneTypes(); + FOSSILS_GENNED.forEach(((stoneType, fossil) -> { + UnSerializedFossilModel model = new UnSerializedFossilModel(stoneType.texture.toString(), fossil.texture.toString(), stoneType.tint); + ResourceLocation blockName = new ResourceLocation(ProjectNublar.MODID, fossil.name.replace(" ", "_").toLowerCase() + "_" + stoneType.name.replace(" ", "_").toLowerCase()); + String string = fossil.name.replace(" ", "_").toLowerCase() + "_" + stoneType.name.replace(" ", "_").toLowerCase(); + PACK.addAsset(fix(blockName, "models/block", "json"), FossilSerializer.serialize(model)); + PACK.addAsset(fix(blockName, "models/item", "json"), FossilSerializer.serialize(model)); + PACK.addAsset(fix(blockName, "blockstates", "json"), FossilSerializer.serialize("projectnublar:block/" + string)); + PACK.addAsset(new ResourceLocation(ProjectNublar.MODID, "pack.mcmeta"), FossilSerializer.serialize()); + PACK.addLang(new ResourceLocation(ProjectNublar.MODID, "en_us"), JLang.lang().entry(WordUtils.capitalizeFully(stoneType.name), WordUtils.capitalizeFully(fossil.name))); + })); + + generateFossilBlocks().forEach(((name, block) -> { + RegistryObject FOSSIL = FOSSIL_BLOCKS.register(name, block); + BLOCKS.add(FOSSIL); + RegistryObject ITEM = ItemHandler.REGISTER.register(name, () -> ((IItemBlock) block.get()).createItem(new Item.Properties().tab(ItemHandler.TAB))); + ITEMS.add(ITEM); + })); + FossilSerializer.serialize(FOSSILS_GENNED); + System.out.println("z"); + } + + //TODO: remove as this is for testing only + public static void addBuiltInFossilsAndTypes() { + System.out.println("rgersrhfg"); + FOSSILS.add(new Fossil(201, 66, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/ammonite"), "Ammonite")); + FOSSILS.add(new Fossil(150, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/feather"), "Feather")); + FOSSILS.add(new Fossil(365, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/feet"), "Feet")); + FOSSILS.add(new Fossil(530, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/fish"), "Fish")); + FOSSILS.add(new Fossil(275, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/imprint"), "Imprint")); + FOSSILS.add(new Fossil(260, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/lizard"), "Lizard")); + FOSSILS.add(new Fossil(500, 0, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/tooth"), "Tooth")); + FOSSILS.add(new Fossil(521, 320, null, new ResourceLocation(ProjectNublar.MODID, "block/fossil/trilobite"), "Trilobite")); + + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/stone"), "Stone", "mineable/pickaxe", Material.STONE, 0, 1.5F, 6.0F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,158, 120, 104), new ResourceLocation("block/granite"), "Granite", "mineable/pickaxe", Material.STONE, 0, 1.5F, 6.0F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/andesite"), "Andesite", "mineable/pickaxe", Material.STONE, 0, 1.5F, 6.0F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/diorite"), "Diorite", "mineable/pickaxe", Material.STONE, 0, 1.5F, 6.0F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/clay"), "Stone", "mineable/pickaxe", Material.STONE, 0, 0.6F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,158, 120, 104), new ResourceLocation("block/terracotta"), "Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/white_terracotta"), "White Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/orange_terracotta"), "Orange Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/magenta_terracotta"), "Magenta Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,158, 120, 104), new ResourceLocation("block/light_blue_terracotta"), "Light Blue Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/yellow_terracotta"), "Yellow Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/lime_terracotta"), "Lime Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/pink_terracotta"), "Pink Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,158, 120, 104), new ResourceLocation("block/gray_terracotta"), "Gray Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/light_gray_terracotta"), "Light Gray Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/cyan_terracotta"), "Cyan Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/purple_terracotta"), "Purple Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/blue_terracotta"), "Blue Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/brown_terracotta"), "Brown Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,158, 120, 104), new ResourceLocation("block/green_terracotta"), "Green Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,145, 145, 145), new ResourceLocation("block/red_terracotta"), "Red Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); + STONE_TYPES.add(new StoneType(1000, 0, color(255,179, 179, 179), new ResourceLocation("block/black_terracotta"), "Black Terracotta", "mineable/pickaxe", Material.STONE, 0, 1.25F, 4.2F)); +// STONE_TYPES.add(new StoneType(1000, 0, color(255,184, 171, 136), new ResourceLocation("block/sandstone"), "Sandstone", "mineable/pickaxe", Material.STONE, 0, 0.8F)); + System.out.println("AX"); + } + + public static void generateAllFossilsAndStoneTypes() { + System.out.println("bg"); + if (FOSSILS_GENNED != null && !FOSSILS_GENNED.isEmpty()) { + } else { + ImmutableMultimap.Builder builder = new ImmutableMultimap.Builder<>(); + for (Fossil fossil : FOSSILS) { + if (fossil.stoneTypes != null) { + for (StoneType stoneType : fossil.stoneTypes) { + builder.put(stoneType, fossil); + } + } else { + List types = Time.findAllStoneTypesThatMatchTimePeriods(Time.findAllTimePeriodsThatMatchRange(fossil.timeStart, fossil.timeEnd)); + for (StoneType type : types) { + builder.put(type, fossil); + } + } + } + FOSSILS_GENNED = builder.build(); + System.out.println("rgwer"); + } + } + + public static int alpha(int pPackedColor) { + return pPackedColor >>> 24; + } + + public static int red(int pPackedColor) { + return pPackedColor >> 16 & 255; + } + + public static int green(int pPackedColor) { + return pPackedColor >> 8 & 255; + } + + public static int blue(int pPackedColor) { + return pPackedColor & 255; + } + + public static int color(int pAlpha, int pRed, int pGreen, int pBlue) { + return pAlpha << 24 | pRed << 16 | pGreen << 8 | pBlue; + } + + //TODO + public static Map> generateFossilBlocks() { + Map> blocks = new HashMap<>(); + generateAllFossilsAndStoneTypes(); + System.out.println("A"); + FOSSILS_GENNED.forEach(((stoneType, fossil) -> { + ResourceLocation blockName = new ResourceLocation(ProjectNublar.MODID, fossil.name.replace(" ", "_").toLowerCase() + "_" + stoneType.name.replace(" ", "_").toLowerCase()); + FossilBlock block = new FossilBlock(AbstractBlock.Properties.of(stoneType.material).noOcclusion().strength(stoneType.strength, stoneType.blastStrength).requiresCorrectToolForDrops().harvestLevel(stoneType.harvestLevel)); + blocks.put(blockName.getPath(), () -> block); + })); + System.out.println("B"); + return blocks; + } + + public static IResourcePack getPack(ResourcePackType type) { + return PACK; + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/StoneType.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/StoneType.java new file mode 100644 index 00000000..4e8e1b5f --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/StoneType.java @@ -0,0 +1,46 @@ +package net.dumbcode.projectnublar.server.fossil; + +import net.minecraft.block.material.Material; +import net.minecraft.util.ResourceLocation; + +public class StoneType { + double start; + double end; + int tint; + ResourceLocation texture; + String name; + /** + * points to a tag. For example "mineable/pickaxe" would point to "mincraft:tags/mineable/pickaxe.json", while "example:mineable/randomname" would point to "example:tags/mineable/randomname.json" + */ + String mineableBy; + Material material; + float strength; + float blastStrength; + int harvestLevel; + + public StoneType(double start, double end, int tint, ResourceLocation texture, String name, String mineableBy, Material material, int harvestLevel, float strength) { + this.start = start; + this.end = end; + this.tint = tint; + this.texture = texture; + this.name = name; + this.mineableBy = mineableBy; + this.material = material; + this.strength = strength; + this.blastStrength = strength; + this.harvestLevel = harvestLevel; + } + + public StoneType(double start, double end, int tint, ResourceLocation texture, String name, String mineableBy, Material material, int harvestLevel, float strength, float blastStrength) { + this.start = start; + this.end = end; + this.tint = tint; + this.texture = texture; + this.name = name; + this.mineableBy = mineableBy; + this.material = material; + this.strength = strength; + this.blastStrength = blastStrength; + this.harvestLevel = harvestLevel; + } +} diff --git a/src/main/java/net/dumbcode/projectnublar/server/fossil/Time.java b/src/main/java/net/dumbcode/projectnublar/server/fossil/Time.java new file mode 100644 index 00000000..5172c972 --- /dev/null +++ b/src/main/java/net/dumbcode/projectnublar/server/fossil/Time.java @@ -0,0 +1,127 @@ +package net.dumbcode.projectnublar.server.fossil; + +import com.google.common.collect.Range; +import com.mojang.datafixers.util.Pair; + +import java.util.ArrayList; +import java.util.List; + +//TODO: HAVE ROCKS AND FOSSILS IDENTIFY TIME PERIODS TO USE FOR SPAWNING +//TODO: add deviation stuff +//TODO: rock strata +public enum Time { + QUATERNARY_HOLOCENE(0.0117, 0), + QUATERNARY_PLEISTOCENE(2.58, 0.0117), + NEOGENE_PLIOCENE(5.333, 2.58), + NEOGENE_MIOCENE(23.03, 5.333), + PALEOGENE_OLIGOCENE(33.9, 23.03), + PALEOGENE_EOCENE(56.0, 33.9), + PALEOGENE_PALEOCENE(66.0, 56.0), + CRETACEOUS_UPPER(100.5, 66.0), + CRETACEOUS_LOWER(145, 100.5), + JURASSIC_UPPER(161.5 /*+-1*/, 145), + JURASSIC_MIDDLE(174.7 /*+-0.8*/, 161.5 /*+-1*/), + JURASSIC_LOWER(201.4 /*+-0.2*/, 174.7 /*+-0.8*/), + TRIASSIC_UPPER(237, 201.4 /*+-0.2*/), + TRIASSIC_MIDDLE(247.2, 237), + TRIASSIC_LOWER(251.902 /*+-0.024*/, 247.2), + PERMIAN_LOPINGIAN(259.51 /*0.21*/, 251.902 /*+-0.024*/), + PERMIAN_GUADALUPIAN(273.01 /*+-0.14*/, 259.51 /*+-0.21*/), + PERMIAN_CISURALIAN(298.9 /*+-0.15*/, 273.01 /*+-0.14*/), + CARBONIFEROUS_PENNSYLVANIAN_UPPER(307 /*+-0.1*/, 298.9 /*+-0.15*/), + CARBONIFEROUS_PENNSYLVANIAN_MIDDLE(315.2 /*+-0.2*/, 307 /*+-0.1*/), + CARBONIFEROUS_PENNSYLVANIAN_LOWER(323.2 /*+-0.4*/, 215.2 /*+-0.2*/), + CARBONIFEROUS_MISSISSIPPIAN_UPPER(330.9 /*+-0.2*/, 323.2 /*+-0.4*/), + CARBONIFEROUS_MISSISSIPPIAN_MIDDLE(346.7 /*+-0.4*/, 330.9 /*+-0.2*/), + CARBONIFEROUS_MISSISSIPPIAN_LOWER(358.9 /*+-0.4*/, 346.7 /*+-0.4*/), + DEVONIAN_UPPER(382.7 /*+-1.6*/, 358.9 /*+-0.4*/), + DEVONIAN_MIDDLE(393.3 /*+-1.2*/, 382.7 /*+-1.6*/), + DEVONIAN_LOWER(419.2 /*+-3.2*/, 393.3 /*+-1.2*/), + SILURIAN_PRIDOLI(423 /*+-2.3*/, 419.2 /*+-3.2*/), + SILURIAN_LUDLOW(427.4 /*+-0.5*/, 423 /*+-2.3*/), + SILURIAN_WENLOCK(433.4 /*+-0.8*/, 427.4 /*+-0.5*/), + SILURIAN_LLANDOVERY(443.8 /*+-1.5*/, 433.4 /*+-0.8*/), + ORDOVICIAN_UPPER(458.4 /*+-0.9*/, 443.8 /*+-1.5*/), + ORDOVICIAN_MIDDLE(470 /*+-1.4*/, 458.4 /*+-0.9*/), + ORDOVICIAN_LOWER(485.4 /*+-1.9*/, 470 /*+-1.4*/), + CAMBRIAN_FURONGIAN(497, 485.4 /*+-1.9*/), + CAMBRIAN_MIAOLINGIAN(509, 497), + CAMBRIAN_SERIES_2(521, 509), + CAMBRIAN_TERRENEUVIAN(538.8 /*+-0.2*/, 521), + PROTEROZOIC_NEOPROTEROZOIC_EDIACARAN(635, 538 /*+-0.2*/), + PROTEROZOIC_NEOPROTEROZOIC_CRYOGENIAN(720, 635), + PROTEROZOIC_NEOPROTEROZOIC_TONIAN(1000, 720), + PROTEROZOIC_MESOPROTER0ZOIC_STENIAN(1200, 1000), + PROTEROZOIC_MESOPROTER0ZOIC_ECTASIAN(1400, 1200), + PROTEROZOIC_MESOPROTER0ZOIC_CALYMMIAN(1600, 1400), + PROTEROZOIC_PALEOPROTEROZOIC_STATHERIAN(1800, 1600), + PROTEROZOIC_PALEOPROTEROZOIC_OROSIRIAN(2050, 1800), + PROTEROZOIC_PALEOPROTEROZOIC_RHYACIAN(2300, 2050), + PROTEROZOIC_PALEOPROTEROZOIC_SIDERIAN(2500, 2300), + ARCHEAN_NEOARCHEAN(2800, 2500), + ARCHEAN_MESOARCHEAN(3200, 2800), + ARCHEAN_PALEOARCHEAN(3600, 3200), + ARCHEAN_EOARCHEAN(4000, 3600), + HADEAN(4567, 4000); + + + + private final double start; + private final double end; + + Time(double start, double end) { + if (end > start) { + throw new IllegalArgumentException("End time cannot be greater than start"); + } + this.start = start; + this.end = end; + } + + Time() { + this.start = 0; + this.end = 0; + } + + public Pair getTimeSpan() { + return new Pair<>(start, end); + } + + public static List