From 4e07ceb8e885055ecdb6b2b9fbd955e9b9d0a80c Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 21:30:09 +0700 Subject: [PATCH 01/21] Androids are now immune to confusion Fixes #159 --- src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt index 249e3bb51..8ab2ecf59 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt @@ -208,5 +208,6 @@ fun addTags(tagsProvider: TagsProvider) { MobEffects.ABSORPTION, MobEffects.SATURATION, MobEffects.DOLPHINS_GRACE, + MobEffects.CONFUSION, ) } From 29cad18e2d50b57bb521c836799798b7919f6091 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 21:31:40 +0700 Subject: [PATCH 02/21] Buff advanced plate press recipe Fixes #154 --- .../dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt index 99c55a285..361ca5e47 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt @@ -52,8 +52,7 @@ fun addCraftingTableRecipes(consumer: Consumer) { .build(consumer) MatteryRecipe(MBlocks.PLATE_PRESS) - .rowB(MItemTags.BASIC_CIRCUIT) - .row(MItemTags.TRITANIUM_PLATES, MItems.MACHINE_FRAME, MItemTags.TRITANIUM_PLATES) + .rowB(MItems.MACHINE_FRAME) .rowAC(MItemTags.PISTONS, MItemTags.PISTONS) .unlockedBy(MItemTags.TRITANIUM_INGOTS) .unlockedBy(MItems.ELECTRIC_PARTS) From 91fab0848f1e5ce586d038a41c76215b310751d2 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 21:32:52 +0700 Subject: [PATCH 03/21] Buff machine frame recipe --- .../recipes/components/machine_frame.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/resources/data/overdrive_that_matters/recipes/components/machine_frame.json b/src/main/resources/data/overdrive_that_matters/recipes/components/machine_frame.json index bfb0bbf73..962530355 100644 --- a/src/main/resources/data/overdrive_that_matters/recipes/components/machine_frame.json +++ b/src/main/resources/data/overdrive_that_matters/recipes/components/machine_frame.json @@ -2,7 +2,7 @@ "type": "minecraft:crafting_shaped", "pattern": [ - "GBG", + "BGB", "PEP", "TET" ], @@ -31,6 +31,6 @@ "result": { "item": "overdrive_that_matters:machine_frame", - "count": 1 + "count": 2 } } \ No newline at end of file From 9fa2aa46cdf56dcb630b43863f39392e476b44b4 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 21:49:49 +0700 Subject: [PATCH 04/21] Buff nanobots regeneration, move balance values to config Fixes #174 --- .../ru/dbotthepony/mc/otm/ServerConfig.kt | 21 +++++++++++++++++++ .../feature/NanobotsRegenerationFeature.kt | 18 ++++------------ 2 files changed, 25 insertions(+), 14 deletions(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/ServerConfig.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/ServerConfig.kt index 7b56c9078..c480ff7df 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/ServerConfig.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/ServerConfig.kt @@ -148,6 +148,26 @@ object ServerConfig { .comment("If this is disabled, any (technically) excess hunger will be nullified, unless playing on peaceful difficulty.") .define("regenerateEnergy", true) + object NanobotsRegeneration { + val COOLDOWN: List by specBuilder + .comment("In ticks, time between heal ticks") + .comment("One heal tick restores 1 heart (2 health points) at most") + .comment("If not getting hurt in specified period of ticks, heal tick takes place, tick timer resets to zero and THIS array' index advances by 1") + .comment("Index inside this array can not exceed of one of ability's") + .comment("") + .comment("Wording in pseudocode:") + .comment("if (ticksSinceTakingDamage >= cooldownConfigOption[healTicks /* or config's biggest index, whichever is smaller */]) {") + .comment(" healTicks = min(healTicks + 1, this.level /* ability level */)") + .comment(" ticksSinceTakingDamage = 0") + .comment(" this.ply.heal(...)") + .comment("}") + .defineList("cooldown", { mutableListOf(80, 60, 40, 20) }) { it is Int } + + val ENERGY_PER_HITPOINT by specBuilder + .comment("Energy required to regenerate 1 health point (half a heart)") + .defineImpreciseFraction("energyPerHitpoint", ImpreciseFraction(800)) + } + val ANDROID_ENERGY_PER_HUNGER_POINT by specBuilder.defineImpreciseFraction("energyPerHunger", ImpreciseFraction(2000), ImpreciseFraction.ZERO) val ANDROID_MAX_ENERGY by specBuilder.comment("Internal battery of every android has this much storage").defineImpreciseFraction("capacity", ImpreciseFraction(80_000), ImpreciseFraction.ZERO) val NIGHT_VISION_POWER_DRAW by specBuilder.defineImpreciseFraction("nightVisionPowerDraw", ImpreciseFraction(8), ImpreciseFraction.ZERO) @@ -223,6 +243,7 @@ object ServerConfig { init { // access instances so spec is built + NanobotsRegeneration EnderTeleporter AndroidJumpBoost AndroidItemMagnet diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsRegenerationFeature.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsRegenerationFeature.kt index 5e9f5a147..d7108cf4c 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsRegenerationFeature.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/android/feature/NanobotsRegenerationFeature.kt @@ -3,6 +3,7 @@ package ru.dbotthepony.mc.otm.android.feature import net.minecraft.nbt.CompoundTag import net.minecraft.server.level.ServerPlayer import net.minecraftforge.event.entity.living.LivingHurtEvent +import ru.dbotthepony.mc.otm.ServerConfig import ru.dbotthepony.mc.otm.android.AndroidFeature import ru.dbotthepony.mc.otm.capability.MatteryPlayerCapability import ru.dbotthepony.mc.otm.core.ImpreciseFraction @@ -19,16 +20,16 @@ class NanobotsRegenerationFeature(android: MatteryPlayerCapability) : AndroidFea if (ply.health > 0f && ply.health < ply.maxHealth) { ticksPassed++ - val waitTime = TICKS_BETWEEN_HEAL.getOrElse(healTicks) { TICKS_BETWEEN_HEAL.last() } + val waitTime = ServerConfig.NanobotsRegeneration.COOLDOWN.getOrElse(healTicks) { ServerConfig.NanobotsRegeneration.COOLDOWN.last() } if (ticksPassed > waitTime) { val missingHealth = (ply.maxHealth - ply.health).coerceAtMost(2f) - val power = ENERGY_PER_HITPOINT * missingHealth + val power = ServerConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT * missingHealth val extracted = android.androidEnergy.extractEnergyInner(power, false) if (extracted.isPositive) { healTicks = (healTicks + 1).coerceAtMost(level) - val healed = (extracted / ENERGY_PER_HITPOINT).toFloat() + val healed = (extracted / ServerConfig.NanobotsRegeneration.ENERGY_PER_HITPOINT).toFloat() ply.heal(healed) (ply as ServerPlayer?)?.awardStat(StatNames.HEALTH_REGENERATED, (healed * 10f).roundToInt()) ticksPassed = 0 @@ -59,15 +60,4 @@ class NanobotsRegenerationFeature(android: MatteryPlayerCapability) : AndroidFea ticksPassed = nbt.getInt("ticksPassed") healTicks = nbt.getInt("healTicks") } - - companion object { - private val ENERGY_PER_HITPOINT = ImpreciseFraction(800) - - private val TICKS_BETWEEN_HEAL = listOf( - 100, // 5 seconds - 80, // 4 seconds - 60, // 3 seconds - 40, // 2 seconds - ) - } } From 1e34b7dfce5f694109ebcc8dce651f592112a453 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 21:53:06 +0700 Subject: [PATCH 05/21] Energy counter reset recipe Fixes #175 --- .../mc/otm/datagen/recipes/CraftingTableRecipes.kt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt index 361ca5e47..3c18ed7a8 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt @@ -43,6 +43,11 @@ fun addCraftingTableRecipes(consumer: Consumer) { .unlockedBy(MItemTags.TRITANIUM_INGOTS_STORAGE) .save(consumer, modLocation("tritanium_ingot_from_storage")) + ShapelessRecipeBuilder(MItems.ENERGY_COUNTER, 1) + .requires(MItems.ENERGY_COUNTER) + .unlockedBy(MItems.ENERGY_COUNTER) + .save(consumer, modLocation("energy_counter_reset")) + MatteryRecipe(MBlocks.PLATE_PRESS) .row(MItems.ELECTRIC_PARTS, MItems.ENERGY_BUS, MItems.ELECTRIC_PARTS) .row(MItemTags.TRITANIUM_INGOTS, Items.BLAST_FURNACE, MItemTags.TRITANIUM_INGOTS) From ebabcdf731b2ae71acb01bc39abfb1818a42b0f9 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 22:27:10 +0700 Subject: [PATCH 06/21] docs --- .../ru/dbotthepony/mc/otm/core/DataStreams.kt | 19 ++++++++++++++++++- .../mc/otm/network/FieldSynchronizer.kt | 18 ++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/core/DataStreams.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/core/DataStreams.kt index bcef9aad4..109f6d260 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/core/DataStreams.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/core/DataStreams.kt @@ -10,11 +10,28 @@ import java.util.function.Predicate import kotlin.NoSuchElementException import kotlin.math.absoluteValue +/** + * Represents value which can be encoded onto or decoded from stream. + * + * Also provides [copy] and [compare] methods + */ interface IStreamCodec { fun read(stream: DataInputStream): V fun write(stream: DataOutputStream, value: V) + + /** + * if value is immutable, return it right away + */ fun copy(value: V): V - fun compare(a: V, b: V): Boolean + + /** + * Optional equality check override. Utilized to determine whenever e.g. network value is different from new value + * + * By default uses [Any.equals] + */ + fun compare(a: V, b: V): Boolean { + return a == b + } } class StreamCodec( diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/network/FieldSynchronizer.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/network/FieldSynchronizer.kt index fe6545364..2525cd189 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/network/FieldSynchronizer.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/network/FieldSynchronizer.kt @@ -94,6 +94,24 @@ enum class MapAction { CLEAR, ADD, REMOVE } +/** + * Universal one-to-many value synchronizer + * + * This class represent collection of synchronizable values (similar to entitydata or menu's dataslots) + * + * Advantages of this class are: + * * It can be freely pooled. You can call [collectNetworkPayload] and [FieldSynchronizer.Endpoint.collectNetworkPayload] as much as you like, + * because they use dirty lists to track which fields need networking. **Warning**: If you attach one or more "observed" values (more on them below), + * each call to above methods will cause scan on observed fields. + * * It is universal. No, seriously, you can use it anywhere, all it needs is you encode [FastByteArrayOutputStream], send it over your + * networking channel, and create [InputStream] to feed to [FieldSynchronizer.Endpoint] + * * Its capabilities at networking are only limited by codecs you provide, see [FieldSynchronizer.Field], [IStreamCodec] + * * Provides not only single values, but also smart [FieldSynchronizer.Map] map synchronization + * * Has network version "conflict" resolver. If source FieldSynchronizer and target FieldSynchronizer have different set of fields, they can figure out how to synchronize + * only known fields. **Keep in mind this only works if you manually specify names on ALL created fields** + * * Directly bytestream embeddable. [FieldSynchronizer.Endpoint] always knows how much bytes to read from incoming stream, you can directly embed it into your data flow + * on network channel. + */ @Suppress("unused") class FieldSynchronizer(private val callback: Runnable, private val alwaysCallCallback: Boolean) { constructor() : this(Runnable {}, false) From f97ec55e0ccab28f11d68b112b84fe40b562b219 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 22:37:01 +0700 Subject: [PATCH 07/21] Why this wasn't done before --- .../ru/dbotthepony/mc/otm/client/screen/MatterPanelScreen.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/MatterPanelScreen.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/MatterPanelScreen.kt index 0453dc22f..986f64a7e 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/MatterPanelScreen.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/MatterPanelScreen.kt @@ -216,6 +216,7 @@ class MatterPanelScreen( val input = object : EditBoxPanel(this@MatterPanelScreen, rowInput) { init { dock = Dock.FILL + requestFocus() } override fun configureNew(widget: EditBox, recreation: Boolean) { From 6e0ccf35fe04cf5d50850841ec47eccf31bbc65e Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 22:38:53 +0700 Subject: [PATCH 08/21] Tick only visible children --- .../ru/dbotthepony/mc/otm/client/screen/panels/EditablePanel.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/panels/EditablePanel.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/panels/EditablePanel.kt index 4783371bd..9b5f3fac1 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/panels/EditablePanel.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/client/screen/panels/EditablePanel.kt @@ -1576,7 +1576,7 @@ open class EditablePanel @JvmOverloads constructor( open fun tick() { tick++ - for (child in Array(childrenInternal.size) { childrenInternal[it] }) { + for (child in Array(visibleChildrenInternal.size) { visibleChildrenInternal[it] }) { child.tick() } } From 6d40cc923f9da21ad1f767c05229a1b10a6e4bb5 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 22:56:31 +0700 Subject: [PATCH 09/21] Nerf tritanium armor values once again, make it slightly worse than diamond armor at protection --- .../ru/dbotthepony/mc/otm/item/TritaniumArmorItem.kt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/item/TritaniumArmorItem.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/item/TritaniumArmorItem.kt index 1b703eb9e..c26c0e48b 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/item/TritaniumArmorItem.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/item/TritaniumArmorItem.kt @@ -34,10 +34,10 @@ private object TritaniumArmorMaterial : ArmorMaterial { override fun getDefenseForSlot(p_40411_: EquipmentSlot): Int { return when (p_40411_) { - EquipmentSlot.FEET -> 4 - EquipmentSlot.LEGS -> 7 - EquipmentSlot.CHEST -> 12 - EquipmentSlot.HEAD -> 5 + EquipmentSlot.FEET -> 3 + EquipmentSlot.LEGS -> 6 + EquipmentSlot.CHEST -> 8 + EquipmentSlot.HEAD -> 3 else -> throw IllegalArgumentException("yo dude what the fuck") } } From d8eef6db10a6b60d6dc930cbd26749aea851bd78 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 22:57:48 +0700 Subject: [PATCH 10/21] Make exosuit upgrades drop only when killed by real player --- .../mc/otm/datagen/loot/LootModifiersData.kt | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt index da2442a1d..47fe28da8 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt @@ -143,12 +143,18 @@ fun addLootModifiers(it: LootModifiers) { )) it.add("wither_exosuit_upgrades", BasicLootAppender( - arrayOf(LootTableIdCondition(EntityType.WITHER.defaultLootTable)), + arrayOf( + LootTableIdCondition(EntityType.WITHER.defaultLootTable), + KilledByRealPlayerOrIndirectly, + ), ItemStack(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_WITHER), )) it.add("ender_dragon_exosuit_upgrades", BasicLootAppender( - arrayOf(LootTableIdCondition(EntityType.ENDER_DRAGON.defaultLootTable)), + arrayOf( + LootTableIdCondition(EntityType.ENDER_DRAGON.defaultLootTable), + KilledByRealPlayerOrIndirectly, + ), ItemStack(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_ENDER_DRAGON), )) } From 1fed86db80c64763ea8bdf32aa01f2f0e9572552 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Wed, 26 Oct 2022 23:46:10 +0700 Subject: [PATCH 11/21] Allow to quickly move items from curio slots --- .../ru/dbotthepony/mc/otm/menu/ExoSuitInventoryMenu.kt | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/menu/ExoSuitInventoryMenu.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/menu/ExoSuitInventoryMenu.kt index 0d43b9d28..f6e720d12 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/menu/ExoSuitInventoryMenu.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/menu/ExoSuitInventoryMenu.kt @@ -87,7 +87,12 @@ class ExoSuitInventoryMenu(val capability: MatteryPlayerCapability) : MatteryMen init { for ((a, b) in curiosSlots) { addSlot(a) - if (b != null) addSlot(b) + storage2Inventory(a) + + if (b != null) { + addSlot(b) + storage2Inventory(b) + } } } From fd1007b164bd0d418829a26d87883ecf8b9f41c7 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 01:04:59 +0700 Subject: [PATCH 12/21] aaaaaaaaaAAAAAAAAAAAAAAA --- .../mc/otm/block/entity/EnergyCounterBlockEntity.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt index d7beedd1a..3bf01d04c 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt @@ -280,7 +280,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat private var resolverOutput = LazyOptional.of { energyOutput } private var resolverInputMekanism = if (isMekanismLoaded) LazyOptional.of { Mattery2MekanismEnergyWrapper(energyInput) } else null - private var resolverOutputMekanism = if (isMekanismLoaded) LazyOptional.of { Mattery2MekanismEnergyWrapper(energyInput) } else null + private var resolverOutputMekanism = if (isMekanismLoaded) LazyOptional.of { Mattery2MekanismEnergyWrapper(energyOutput) } else null private var valid = true @@ -301,7 +301,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat if (isMekanismLoaded) { resolverInputMekanism = LazyOptional.of { Mattery2MekanismEnergyWrapper(energyInput) } - resolverOutputMekanism = LazyOptional.of { Mattery2MekanismEnergyWrapper(energyInput) } + resolverOutputMekanism = LazyOptional.of { Mattery2MekanismEnergyWrapper(energyOutput) } } } From ef074721f8baf5c85db6a1c20e858e08d7d4ce9c Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 01:07:14 +0700 Subject: [PATCH 13/21] rename --- .../block/entity/EnergyCounterBlockEntity.kt | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt index 3bf01d04c..94de468df 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/block/entity/EnergyCounterBlockEntity.kt @@ -16,7 +16,6 @@ import net.minecraftforge.common.capabilities.Capability import net.minecraftforge.common.capabilities.ForgeCapabilities import net.minecraftforge.common.util.LazyOptional import net.minecraftforge.energy.IEnergyStorage -import net.minecraftforge.network.PacketDistributor import ru.dbotthepony.mc.otm.* import ru.dbotthepony.mc.otm.block.EnergyCounterBlock import ru.dbotthepony.mc.otm.capability.* @@ -126,13 +125,13 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat tickOnceServer(this::checkSurroundings) } - private inner class EnergyCounterCap(val is_input: Boolean) : IMatteryEnergyStorage { + private inner class EnergyCounterCap(val isInput: Boolean) : IMatteryEnergyStorage { override fun extractEnergyOuter(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { return extractEnergyInner(howMuch, simulate) } override fun extractEnergyInner(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { - if (is_input) + if (isInput) return ImpreciseFraction.ZERO if (inputCapability.isPresent) { @@ -164,7 +163,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat } override fun receiveEnergyInner(howMuch: ImpreciseFraction, simulate: Boolean): ImpreciseFraction { - if (!is_input) + if (!isInput) return ImpreciseFraction.ZERO if (outputCapability.isPresent) { @@ -193,7 +192,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat override val batteryLevel: ImpreciseFraction get() { - if (is_input) { + if (isInput) { if (outputCapability.isPresent) { val it = outputCapability.resolve().get() @@ -220,7 +219,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat override val maxBatteryLevel: ImpreciseFraction get() { - if (is_input) { + if (isInput) { if (outputCapability.isPresent) { val it = outputCapability.resolve().get() @@ -247,7 +246,7 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat override val missingPower: ImpreciseFraction get() { - if (is_input) { + if (isInput) { if (outputCapability.isPresent) { val it = outputCapability.resolve().get() @@ -272,8 +271,8 @@ class EnergyCounterBlockEntity(p_155229_: BlockPos, p_155230_: BlockState) : Mat return ImpreciseFraction.ZERO } - override fun canExtract() = !is_input - override fun canReceive() = is_input + override fun canExtract() = !isInput + override fun canReceive() = isInput } private var resolverInput = LazyOptional.of { energyInput } From 486a668e8ac4d79d2f414d45434bd49aecd65d95 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 14:17:22 +0700 Subject: [PATCH 14/21] Get rid of basic and plant loot appenders Almost fixes #191 --- .../mc/otm/datagen/loot/LootModifiers.kt | 47 ++++++++++++++++ .../mc/otm/datagen/loot/LootModifiersData.kt | 5 +- .../mc/otm/datagen/loot/LootTables.kt | 13 ++++- .../mc/otm/data/BasicLootAppender.kt | 54 ------------------- .../mc/otm/data/ChanceCondition.kt | 44 +++++++++++++++ .../otm/data/ChanceWithPlaytimeCondition.kt | 2 +- .../mc/otm/data/ItemInInventoryCondition.kt | 2 +- .../mc/otm/data/LootPoolAppender.kt | 5 +- .../mc/otm/data/PlainLootAppender.kt | 52 ------------------ .../mc/otm/registry/LootModifiers.kt | 6 +-- .../mc/otm/registry/MLootItemConditions.kt | 4 +- 11 files changed, 114 insertions(+), 120 deletions(-) delete mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/BasicLootAppender.kt create mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt delete mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/PlainLootAppender.kt diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt index e30f859ad..c79f373f3 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt @@ -1,8 +1,55 @@ package ru.dbotthepony.mc.otm.datagen.loot import net.minecraft.data.DataGenerator +import net.minecraft.world.item.ItemStack +import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraftforge.common.data.GlobalLootModifierProvider +import ru.dbotthepony.mc.otm.data.LootPoolAppender import ru.dbotthepony.mc.otm.datagen.DataGen +import java.util.Arrays +import java.util.stream.Stream + +@Suppress("FunctionName") +fun BasicLootAppender( + conditions: Array, + items: Stream +): LootPoolAppender { + return LootPoolAppender(conditions, items.map { + lootPool { + item(it.item) { + setCount(it.count) + } + }.build() + }) +} + +@Suppress("FunctionName") +fun BasicLootAppender( + conditions: Array, + vararg items: ItemStack +) = BasicLootAppender(conditions, Arrays.stream(items)) + +@Suppress("FunctionName") +fun PlainLootAppender( + conditions: Array, + items: Stream> +): LootPoolAppender { + return LootPoolAppender(conditions, items.map { + lootPool { + item(it.first.item) { + setCount(it.first.count) + } + + chanceCondition(it.second) + }.build() + }) +} + +@Suppress("FunctionName") +fun PlainLootAppender( + conditions: Array, + vararg items: Pair +) = PlainLootAppender(conditions, Arrays.stream(items)) class LootModifiers(generator: DataGenerator) : GlobalLootModifierProvider(generator, DataGen.MOD_ID) { private val lambdas = ArrayList<(LootModifiers) -> Unit>() diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt index 47fe28da8..9cd5a35bf 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt @@ -11,17 +11,16 @@ import ru.dbotthepony.mc.otm.data.ChanceWithPlaytimeCondition import ru.dbotthepony.mc.otm.data.HasExosuitCondition import ru.dbotthepony.mc.otm.data.IRandomizableItem import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition -import ru.dbotthepony.mc.otm.data.KilledByRealPlayer -import ru.dbotthepony.mc.otm.data.BasicLootAppender import ru.dbotthepony.mc.otm.data.KilledByRealPlayerOrIndirectly -import ru.dbotthepony.mc.otm.data.PlainLootAppender import ru.dbotthepony.mc.otm.data.RandomizableItemLootAppender import ru.dbotthepony.mc.otm.registry.MItems +@Suppress("FunctionName") fun LootTableIdCondition(location: String): LootItemCondition { return LootTableIdCondition.Builder(ResourceLocation("minecraft", location)).build() } +@Suppress("FunctionName") fun LootTableIdCondition(location: ResourceLocation): LootItemCondition { return LootTableIdCondition.Builder(location).build() } diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt index 157ee486e..ccae782fe 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt @@ -33,11 +33,10 @@ import net.minecraft.world.level.storage.loot.providers.number.ConstantValue import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity import ru.dbotthepony.mc.otm.block.entity.MatteryWorkerBlockEntity -import ru.dbotthepony.mc.otm.core.registryName +import ru.dbotthepony.mc.otm.data.ChanceCondition import java.util.function.BiConsumer import java.util.function.Consumer import java.util.function.Supplier -import kotlin.reflect.full.isSubclassOf private typealias LootTableSaver = BiConsumer private typealias LootTableCallback = Consumer @@ -45,6 +44,8 @@ private typealias LootTableCallbackProvider = Supplier private typealias LootTuple = Pair inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool(LootPool.lootPool().also(configurator)) +inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool.Builder = LootPool.lootPool().also(configurator) + inline fun LootPool.Builder.item(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit) { add(LootItem.lootTableItem(item).also(configurator)) } @@ -55,6 +56,9 @@ fun LootPool.Builder.setRolls(count: Float): LootPool.Builder = setRolls(Constan fun LootPool.Builder.setRolls(min: Int, max: Int): LootPool.Builder = setRolls(UniformGenerator.between(min.toFloat(), max.toFloat())) fun LootPool.Builder.setRolls(min: Float, max: Float): LootPool.Builder = setRolls(UniformGenerator.between(min, max)) +fun LootPool.Builder.condition(value: LootItemCondition.Builder): LootPool.Builder = `when`(value) +fun LootPool.Builder.chanceCondition(chance: Double): LootPool.Builder = condition(ChanceCondition(chance)) + fun > T.setCount(count: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { apply(SetItemCountFunction.setCount(ConstantValue.exactly(count.toFloat())).also(configurator)) return this @@ -90,6 +94,11 @@ inline fun > T.blockStateCondition(bl return this } +fun > T.chanceCondition(chance: Double): T { + condition(ChanceCondition(chance)) + return this +} + operator fun StatePropertiesPredicate.Builder.set(property: Property<*>, value: String): StatePropertiesPredicate.Builder = hasProperty(property, value) operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Int): StatePropertiesPredicate.Builder = hasProperty(property, value) operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Boolean): StatePropertiesPredicate.Builder = hasProperty(property, value) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/BasicLootAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/BasicLootAppender.kt deleted file mode 100644 index 85bcac885..000000000 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/BasicLootAppender.kt +++ /dev/null @@ -1,54 +0,0 @@ -package ru.dbotthepony.mc.otm.data - -import com.google.common.collect.ImmutableList -import com.mojang.serialization.Codec -import com.mojang.serialization.codecs.RecordCodecBuilder -import it.unimi.dsi.fastutil.objects.ObjectArrayList -import net.minecraft.world.item.ItemStack -import net.minecraft.world.level.storage.loot.LootContext -import net.minecraft.world.level.storage.loot.predicates.LootItemCondition -import net.minecraftforge.common.loot.IGlobalLootModifier -import net.minecraftforge.common.loot.LootModifier -import java.util.Arrays -import java.util.stream.Stream - -class BasicLootAppender( - conditions: Array, - items: Stream -) : LootModifier(conditions) { - constructor( - conditions: Array, - items: Collection - ) : this(conditions, items.stream()) - - constructor( - conditions: Array, - vararg items: ItemStack - ) : this(conditions, Arrays.stream(items)) - - private val items = items.map { it.copy() }.collect(ImmutableList.toImmutableList()) - - override fun codec(): Codec { - return CODEC - } - - override fun doApply( - generatedLoot: ObjectArrayList, - context: LootContext - ): ObjectArrayList { - for (item in items) - generatedLoot.add(item.copy()) - - return generatedLoot - } - - companion object { - val CODEC: Codec by lazy { - RecordCodecBuilder.create { - codecStart(it) - .and(ItemStackCodec.LIST.fieldOf("items").forGetter(BasicLootAppender::items)) - .apply(it, ::BasicLootAppender) - } - } - } -} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt new file mode 100644 index 000000000..78eb4d696 --- /dev/null +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt @@ -0,0 +1,44 @@ +package ru.dbotthepony.mc.otm.data + +import com.google.gson.JsonDeserializationContext +import com.google.gson.JsonObject +import com.google.gson.JsonPrimitive +import com.google.gson.JsonSerializationContext +import com.google.gson.JsonSyntaxException +import net.minecraft.world.level.storage.loot.LootContext +import net.minecraft.world.level.storage.loot.Serializer +import net.minecraft.world.level.storage.loot.predicates.LootItemCondition +import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType +import ru.dbotthepony.mc.otm.core.set +import ru.dbotthepony.mc.otm.registry.MLootItemConditions + +/** + * u serious? + */ +data class ChanceCondition(val chance: Double) : LootItemCondition, LootItemCondition.Builder { + init { + require(chance in 0.0 .. 1.0) { "Invalid chance: $chance" } + } + + override fun test(t: LootContext): Boolean { + return t.random.nextDouble() < chance + } + + override fun getType(): LootItemConditionType { + return MLootItemConditions.CHANCE + } + + override fun build(): LootItemCondition { + return this + } + + companion object : Serializer { + override fun serialize(p_79325_: JsonObject, p_79326_: ChanceCondition, p_79327_: JsonSerializationContext) { + p_79325_["chance"] = JsonPrimitive(p_79326_.chance) + } + + override fun deserialize(p_79323_: JsonObject, p_79324_: JsonDeserializationContext): ChanceCondition { + return ChanceCondition(p_79323_["chance"]?.asDouble ?: throw JsonSyntaxException("Invalid chance json element")) + } + } +} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt index 4922085f4..da79a0e9f 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt @@ -13,7 +13,7 @@ import ru.dbotthepony.mc.otm.capability.matteryPlayer import ru.dbotthepony.mc.otm.core.set import ru.dbotthepony.mc.otm.registry.MLootItemConditions -class ChanceWithPlaytimeCondition( +data class ChanceWithPlaytimeCondition( val minPlaytime: Int = 0, val maxPlaytime: Int, val minProbability: Double, diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt index ad9a33330..34d214c2b 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt @@ -19,7 +19,7 @@ import ru.dbotthepony.mc.otm.core.registryName import ru.dbotthepony.mc.otm.core.set import ru.dbotthepony.mc.otm.registry.MLootItemConditions -class ItemInInventoryCondition( +data class ItemInInventoryCondition( val item: ItemStack, val matchDamage: Boolean = false, val matchNBT: Boolean = false, diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt index cf1b69275..27f792704 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt @@ -25,7 +25,10 @@ class LootPoolAppender(conditions: Array, pools: Stream, vararg pools: LootPool) : this(conditions, Arrays.stream(pools)) override fun doApply(generatedLoot: ObjectArrayList, context: LootContext): ObjectArrayList { - pools.forEach { it.addRandomItems(generatedLoot::add, context) } + for (pool in pools) { + pool.addRandomItems(generatedLoot::add, context) + } + return generatedLoot } diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/PlainLootAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/PlainLootAppender.kt deleted file mode 100644 index 614933aef..000000000 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/PlainLootAppender.kt +++ /dev/null @@ -1,52 +0,0 @@ -package ru.dbotthepony.mc.otm.data - -import com.google.common.collect.ImmutableList -import com.mojang.serialization.Codec -import com.mojang.serialization.codecs.RecordCodecBuilder -import it.unimi.dsi.fastutil.objects.ObjectArrayList -import net.minecraft.world.item.ItemStack -import net.minecraft.world.level.storage.loot.LootContext -import net.minecraft.world.level.storage.loot.predicates.LootItemCondition -import net.minecraftforge.common.loot.IGlobalLootModifier -import net.minecraftforge.common.loot.LootModifier -import java.util.* -import java.util.stream.Stream - -class PlainLootAppender(conditions: Array, entries: Stream>) : LootModifier(conditions) { - constructor(conditions: Array, vararg entries: Pair) : this(conditions, Arrays.stream(entries)) - constructor(conditions: Array, entries: Collection>) : this(conditions, entries.stream()) - - private val entries = entries.map { it.first.copy() to it.second }.collect(ImmutableList.toImmutableList()) - - override fun doApply(generatedLoot: ObjectArrayList, context: LootContext): ObjectArrayList { - for ((item, chance) in entries) { - if (context.random.nextDouble() <= chance) { - generatedLoot.add(item.copy()) - } - } - - return generatedLoot - } - - override fun codec(): Codec { - return CODEC - } - - companion object { - private val paircodec: Codec> = RecordCodecBuilder.create { - it.group( - ItemStackCodec.fieldOf("item").forGetter { it.first }, - Codec.DOUBLE.fieldOf("chance").forGetter { it.second } - ).apply(it, ::Pair) - } - - private val pairlistcodec = Codec.list(paircodec) - - val CODEC: Codec = - RecordCodecBuilder.create { - codecStart(it).and( - pairlistcodec.fieldOf("entries").forGetter(PlainLootAppender::entries) - ).apply(it, ::PlainLootAppender) - } - } -} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt index d9051b0b2..aa0eb0bb5 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt @@ -5,8 +5,6 @@ import net.minecraftforge.registries.DeferredRegister import net.minecraftforge.registries.ForgeRegistries import ru.dbotthepony.mc.otm.OverdriveThatMatters import ru.dbotthepony.mc.otm.data.LootPoolAppender -import ru.dbotthepony.mc.otm.data.BasicLootAppender -import ru.dbotthepony.mc.otm.data.PlainLootAppender import ru.dbotthepony.mc.otm.data.RandomizableItemLootAppender object LootModifiers { @@ -14,9 +12,7 @@ object LootModifiers { init { registry.register("loot_appender") { LootPoolAppender.CODEC } - registry.register("loot_appender_separated") { PlainLootAppender.CODEC } - registry.register("loot_appender_basic") { BasicLootAppender.CODEC } - registry.register("randomizable_item_loot_appender") { RandomizableItemLootAppender.Companion } + registry.register("randomized_appender") { RandomizableItemLootAppender.Companion } } internal fun register(bus: IEventBus) { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt index c8dd6339a..ec467d01e 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt @@ -3,7 +3,6 @@ package ru.dbotthepony.mc.otm.registry import net.minecraft.core.Registry import net.minecraft.resources.ResourceLocation import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType -import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent import net.minecraftforge.registries.RegisterEvent import ru.dbotthepony.mc.otm.OverdriveThatMatters import ru.dbotthepony.mc.otm.data.ChanceWithPlaytimeCondition @@ -11,6 +10,7 @@ import ru.dbotthepony.mc.otm.data.HasExosuitCondition import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition import ru.dbotthepony.mc.otm.data.KilledByRealPlayer import ru.dbotthepony.mc.otm.data.KilledByRealPlayerOrIndirectly +import ru.dbotthepony.mc.otm.data.ChanceCondition object MLootItemConditions { val HAS_EXOSUIT = LootItemConditionType(HasExosuitCondition) @@ -18,6 +18,7 @@ object MLootItemConditions { val KILLED_BY_REAL_PLAYER_OR_INDIRECTLY = LootItemConditionType(KilledByRealPlayerOrIndirectly) val CHANCE_WITH_PLAYTIME = LootItemConditionType(ChanceWithPlaytimeCondition) val ITEM_IN_INVENTORY = LootItemConditionType(ItemInInventoryCondition) + val CHANCE = LootItemConditionType(ChanceCondition.Companion) internal fun register(event: RegisterEvent) { if (event.getVanillaRegistry() == Registry.LOOT_CONDITION_TYPE) { @@ -26,6 +27,7 @@ object MLootItemConditions { Registry.LOOT_CONDITION_TYPE.register(ResourceLocation(OverdriveThatMatters.MOD_ID, "item_in_inventory"), ITEM_IN_INVENTORY) Registry.LOOT_CONDITION_TYPE.register(ResourceLocation(OverdriveThatMatters.MOD_ID, "killed_by_real_player"), KILLED_BY_REAL_PLAYER) Registry.LOOT_CONDITION_TYPE.register(ResourceLocation(OverdriveThatMatters.MOD_ID, "killed_by_real_player_or_indirectly"), KILLED_BY_REAL_PLAYER_OR_INDIRECTLY) + Registry.LOOT_CONDITION_TYPE.register(ResourceLocation(OverdriveThatMatters.MOD_ID, "chance"), CHANCE) } } } From 37eea6f2e0aa9fedd29f5e363c8a496ef3c813e7 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 14:19:18 +0700 Subject: [PATCH 15/21] Move conditions to subpackage --- .../mc/otm/datagen/loot/LootModifiersData.kt | 6 +++--- .../ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt | 2 +- .../mc/otm/data/{ => condition}/ChanceCondition.kt | 2 +- .../{ => condition}/ChanceWithPlaytimeCondition.kt | 2 +- .../mc/otm/data/{ => condition}/HasExosuitCondition.kt | 2 +- .../mc/otm/data/{ => condition}/KilledByRealPlayer.kt | 3 +-- .../{ => condition}/KilledByRealPlayerOrIndirectly.kt | 2 +- .../dbotthepony/mc/otm/registry/MLootItemConditions.kt | 10 +++++----- 8 files changed, 14 insertions(+), 15 deletions(-) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/ChanceCondition.kt (97%) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/ChanceWithPlaytimeCondition.kt (98%) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/HasExosuitCondition.kt (96%) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/KilledByRealPlayer.kt (94%) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/KilledByRealPlayerOrIndirectly.kt (97%) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt index 9cd5a35bf..234dda79b 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt @@ -7,11 +7,11 @@ import net.minecraft.world.item.Rarity import net.minecraft.world.level.storage.loot.BuiltInLootTables import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraftforge.common.loot.LootTableIdCondition -import ru.dbotthepony.mc.otm.data.ChanceWithPlaytimeCondition -import ru.dbotthepony.mc.otm.data.HasExosuitCondition +import ru.dbotthepony.mc.otm.data.condition.ChanceWithPlaytimeCondition +import ru.dbotthepony.mc.otm.data.condition.HasExosuitCondition import ru.dbotthepony.mc.otm.data.IRandomizableItem import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition -import ru.dbotthepony.mc.otm.data.KilledByRealPlayerOrIndirectly +import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayerOrIndirectly import ru.dbotthepony.mc.otm.data.RandomizableItemLootAppender import ru.dbotthepony.mc.otm.registry.MItems diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt index ccae782fe..9802d961f 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt @@ -33,7 +33,7 @@ import net.minecraft.world.level.storage.loot.providers.number.ConstantValue import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity import ru.dbotthepony.mc.otm.block.entity.MatteryWorkerBlockEntity -import ru.dbotthepony.mc.otm.data.ChanceCondition +import ru.dbotthepony.mc.otm.data.condition.ChanceCondition import java.util.function.BiConsumer import java.util.function.Consumer import java.util.function.Supplier diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceCondition.kt similarity index 97% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceCondition.kt index 78eb4d696..bb92e5431 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceCondition.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt similarity index 98% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt index da79a0e9f..af1e4118b 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ChanceWithPlaytimeCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/HasExosuitCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt similarity index 96% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/HasExosuitCondition.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt index 3f866f7e6..69c5b158e 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/HasExosuitCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayer.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt similarity index 94% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayer.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt index b23caa8ff..642d14ce9 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayer.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject @@ -10,7 +10,6 @@ import net.minecraft.world.level.storage.loot.predicates.InvertedLootItemConditi import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import net.minecraftforge.common.util.FakePlayer -import ru.dbotthepony.mc.otm.capability.matteryPlayer import ru.dbotthepony.mc.otm.registry.MLootItemConditions object KilledByRealPlayer : LootItemCondition, Serializer, LootItemCondition.Builder { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayerOrIndirectly.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt similarity index 97% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayerOrIndirectly.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt index 99bd4b5b3..e08b59e5a 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/KilledByRealPlayerOrIndirectly.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt index ec467d01e..9bee9fa46 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt @@ -5,12 +5,12 @@ import net.minecraft.resources.ResourceLocation import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import net.minecraftforge.registries.RegisterEvent import ru.dbotthepony.mc.otm.OverdriveThatMatters -import ru.dbotthepony.mc.otm.data.ChanceWithPlaytimeCondition -import ru.dbotthepony.mc.otm.data.HasExosuitCondition +import ru.dbotthepony.mc.otm.data.condition.ChanceWithPlaytimeCondition +import ru.dbotthepony.mc.otm.data.condition.HasExosuitCondition import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition -import ru.dbotthepony.mc.otm.data.KilledByRealPlayer -import ru.dbotthepony.mc.otm.data.KilledByRealPlayerOrIndirectly -import ru.dbotthepony.mc.otm.data.ChanceCondition +import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayer +import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayerOrIndirectly +import ru.dbotthepony.mc.otm.data.condition.ChanceCondition object MLootItemConditions { val HAS_EXOSUIT = LootItemConditionType(HasExosuitCondition) From a2345fa602556f5ebceb8b5da486aaa66308196a Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 14:19:57 +0700 Subject: [PATCH 16/21] More moves --- .../mc/otm/datagen/loot/LootModifiers.kt | 2 +- .../mc/otm/datagen/loot/LootModifiersData.kt | 21 ++++++++++++------- .../ItemInInventoryCondition.kt | 2 +- .../mc/otm/data/loot/IRandomizableItem.kt | 11 ++++++++++ .../otm/data/{ => loot}/LootPoolAppender.kt | 2 +- .../RandomizableItemLootAppender.kt | 12 +++-------- .../item/ProceduralExoSuitSlotUpgradeItem.kt | 5 +++-- .../mc/otm/registry/LootModifiers.kt | 4 ++-- .../mc/otm/registry/MLootItemConditions.kt | 2 +- 9 files changed, 36 insertions(+), 25 deletions(-) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => condition}/ItemInInventoryCondition.kt (98%) create mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => loot}/LootPoolAppender.kt (98%) rename src/main/kotlin/ru/dbotthepony/mc/otm/data/{ => loot}/RandomizableItemLootAppender.kt (94%) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt index c79f373f3..77a42d003 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt @@ -4,7 +4,7 @@ import net.minecraft.data.DataGenerator import net.minecraft.world.item.ItemStack import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraftforge.common.data.GlobalLootModifierProvider -import ru.dbotthepony.mc.otm.data.LootPoolAppender +import ru.dbotthepony.mc.otm.data.loot.LootPoolAppender import ru.dbotthepony.mc.otm.datagen.DataGen import java.util.Arrays import java.util.stream.Stream diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt index 234dda79b..adcff7df2 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt @@ -9,10 +9,10 @@ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraftforge.common.loot.LootTableIdCondition import ru.dbotthepony.mc.otm.data.condition.ChanceWithPlaytimeCondition import ru.dbotthepony.mc.otm.data.condition.HasExosuitCondition -import ru.dbotthepony.mc.otm.data.IRandomizableItem -import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition +import ru.dbotthepony.mc.otm.data.loot.IRandomizableItem +import ru.dbotthepony.mc.otm.data.condition.ItemInInventoryCondition import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayerOrIndirectly -import ru.dbotthepony.mc.otm.data.RandomizableItemLootAppender +import ru.dbotthepony.mc.otm.data.loot.RandomizableItemLootAppender import ru.dbotthepony.mc.otm.registry.MItems @Suppress("FunctionName") @@ -39,7 +39,8 @@ fun addLootModifiers(it: LootModifiers) { RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.2), RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.05, rarity = Rarity.UNCOMMON) ) - )) + ) + ) it.add("mineshaft_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), @@ -54,7 +55,8 @@ fun addLootModifiers(it: LootModifiers) { RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.1), RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.01, rarity = Rarity.UNCOMMON) ) - )) + ) + ) it.add("mineshaft_nutrient_paste", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), @@ -75,7 +77,8 @@ fun addLootModifiers(it: LootModifiers) { RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.UNCOMMON), RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.25, rarity = Rarity.COMMON), ) - )) + ) + ) it.add("jungle_temple_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.JUNGLE_TEMPLE)), @@ -88,7 +91,8 @@ fun addLootModifiers(it: LootModifiers) { RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.UNCOMMON), RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.35, rarity = Rarity.RARE) ) - )) + ) + ) it.add("end_city_modifications", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.END_CITY_TREASURE)), @@ -105,7 +109,8 @@ fun addLootModifiers(it: LootModifiers) { RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.2, rarity = Rarity.RARE), RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.EPIC), ) - )) + ) + ) it.add("shipwreck_supply_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.SHIPWRECK_SUPPLY)), diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt similarity index 98% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt index 34d214c2b..fbad4de61 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/ItemInInventoryCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.condition import com.google.gson.JsonDeserializationContext import com.google.gson.JsonObject diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt new file mode 100644 index 000000000..42ba6ca86 --- /dev/null +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt @@ -0,0 +1,11 @@ +package ru.dbotthepony.mc.otm.data.loot + +import net.minecraft.util.RandomSource +import net.minecraft.world.entity.player.Player +import net.minecraft.world.item.ItemStack +import net.minecraft.world.item.Rarity +import net.minecraft.world.level.ItemLike + +interface IRandomizableItem : ItemLike { + fun randomize(itemStack: ItemStack, random: RandomSource, ply: Player?, rarity: Rarity = Rarity.COMMON) +} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt similarity index 98% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt index 27f792704..fea33bfb0 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/LootPoolAppender.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.loot import com.google.common.collect.ImmutableList import com.google.gson.* diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/RandomizableItemLootAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt similarity index 94% rename from src/main/kotlin/ru/dbotthepony/mc/otm/data/RandomizableItemLootAppender.kt rename to src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt index 7b09b384b..d78cbc834 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/RandomizableItemLootAppender.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt @@ -1,4 +1,4 @@ -package ru.dbotthepony.mc.otm.data +package ru.dbotthepony.mc.otm.data.loot import com.google.common.collect.ImmutableList import com.mojang.datafixers.util.Pair @@ -7,24 +7,18 @@ import com.mojang.serialization.DataResult import com.mojang.serialization.DynamicOps import com.mojang.serialization.codecs.RecordCodecBuilder import it.unimi.dsi.fastutil.objects.ObjectArrayList -import net.minecraft.util.RandomSource import net.minecraft.util.valueproviders.ConstantInt import net.minecraft.util.valueproviders.IntProvider -import net.minecraft.util.valueproviders.UniformInt import net.minecraft.world.entity.player.Player import net.minecraft.world.item.Item import net.minecraft.world.item.ItemStack import net.minecraft.world.item.Rarity -import net.minecraft.world.level.ItemLike import net.minecraft.world.level.storage.loot.LootContext import net.minecraft.world.level.storage.loot.parameters.LootContextParams import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraftforge.common.loot.LootModifier import net.minecraftforge.registries.ForgeRegistries - -interface IRandomizableItem : ItemLike { - fun randomize(itemStack: ItemStack, random: RandomSource, ply: Player?, rarity: Rarity = Rarity.COMMON) -} +import ru.dbotthepony.mc.otm.data.codec class RandomizableItemLootAppender( conditions: Array, @@ -68,7 +62,7 @@ class RandomizableItemLootAppender( IntProvider.CODEC.fieldOf("count").forGetter(Entry::count), Rarity::class.codec().fieldOf("rarity").forGetter(Entry::rarity), Codec.BOOL.fieldOf("distinct").forGetter(Entry::distinct), - ).apply(it, ::Entry) + ).apply(it, RandomizableItemLootAppender::Entry) } } } diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/item/ProceduralExoSuitSlotUpgradeItem.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/item/ProceduralExoSuitSlotUpgradeItem.kt index ac562f433..d443bc476 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/item/ProceduralExoSuitSlotUpgradeItem.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/item/ProceduralExoSuitSlotUpgradeItem.kt @@ -11,11 +11,12 @@ import net.minecraft.world.level.Level import ru.dbotthepony.mc.otm.core.TranslatableComponent import ru.dbotthepony.mc.otm.core.set import ru.dbotthepony.mc.otm.core.tagNotNull -import ru.dbotthepony.mc.otm.data.IRandomizableItem +import ru.dbotthepony.mc.otm.data.loot.IRandomizableItem import java.util.* @Suppress("NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS") // .tab(null) is a legal statement because tab field itself is nullable -class ProceduralExoSuitSlotUpgradeItem : AbstractExoSuitSlotUpgradeItem(defaultProperties().tab(null)), IRandomizableItem { +class ProceduralExoSuitSlotUpgradeItem : AbstractExoSuitSlotUpgradeItem(defaultProperties().tab(null)), + IRandomizableItem { override fun getRarity(itemStack: ItemStack): Rarity { return when (slotCount(itemStack)) { in 0 .. 9 -> Rarity.COMMON diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt index aa0eb0bb5..4a92c8123 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt @@ -4,8 +4,8 @@ import net.minecraftforge.eventbus.api.IEventBus import net.minecraftforge.registries.DeferredRegister import net.minecraftforge.registries.ForgeRegistries import ru.dbotthepony.mc.otm.OverdriveThatMatters -import ru.dbotthepony.mc.otm.data.LootPoolAppender -import ru.dbotthepony.mc.otm.data.RandomizableItemLootAppender +import ru.dbotthepony.mc.otm.data.loot.LootPoolAppender +import ru.dbotthepony.mc.otm.data.loot.RandomizableItemLootAppender object LootModifiers { private val registry = DeferredRegister.create(ForgeRegistries.Keys.GLOBAL_LOOT_MODIFIER_SERIALIZERS, OverdriveThatMatters.MOD_ID) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt index 9bee9fa46..6070f0c7c 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MLootItemConditions.kt @@ -7,7 +7,7 @@ import net.minecraftforge.registries.RegisterEvent import ru.dbotthepony.mc.otm.OverdriveThatMatters import ru.dbotthepony.mc.otm.data.condition.ChanceWithPlaytimeCondition import ru.dbotthepony.mc.otm.data.condition.HasExosuitCondition -import ru.dbotthepony.mc.otm.data.ItemInInventoryCondition +import ru.dbotthepony.mc.otm.data.condition.ItemInInventoryCondition import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayer import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayerOrIndirectly import ru.dbotthepony.mc.otm.data.condition.ChanceCondition From f319bd9287c45af466c7a7d03c51aa7d9b9ec44f Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 14:22:13 +0700 Subject: [PATCH 17/21] Split kotlin dsl extensions from loottables file --- .../ru/dbotthepony/mc/otm/datagen/loot/DSL.kt | 91 +++++++++++++++++++ .../mc/otm/datagen/loot/LootTables.kt | 74 --------------- 2 files changed, 91 insertions(+), 74 deletions(-) create mode 100644 src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt new file mode 100644 index 000000000..a1877e520 --- /dev/null +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt @@ -0,0 +1,91 @@ +package ru.dbotthepony.mc.otm.datagen.loot + +import net.minecraft.advancements.critereon.StatePropertiesPredicate +import net.minecraft.util.StringRepresentable +import net.minecraft.world.level.ItemLike +import net.minecraft.world.level.block.Block +import net.minecraft.world.level.block.state.properties.Property +import net.minecraft.world.level.storage.loot.LootPool +import net.minecraft.world.level.storage.loot.LootTable +import net.minecraft.world.level.storage.loot.entries.LootItem +import net.minecraft.world.level.storage.loot.entries.LootPoolSingletonContainer +import net.minecraft.world.level.storage.loot.functions.LootItemConditionalFunction +import net.minecraft.world.level.storage.loot.functions.SetItemCountFunction +import net.minecraft.world.level.storage.loot.predicates.LootItemBlockStatePropertyCondition +import net.minecraft.world.level.storage.loot.predicates.LootItemCondition +import net.minecraft.world.level.storage.loot.providers.number.ConstantValue +import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator +import ru.dbotthepony.mc.otm.data.condition.ChanceCondition + +inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool( + LootPool.lootPool().also(configurator)) +inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool.Builder = LootPool.lootPool().also(configurator) +inline fun LootPool.Builder.item(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit) { + add(LootItem.lootTableItem(item).also(configurator)) +} + +fun LootPool.Builder.setRolls(count: Int): LootPool.Builder = setRolls(ConstantValue.exactly(count.toFloat())) +fun LootPool.Builder.setRolls(count: Float): LootPool.Builder = setRolls(ConstantValue.exactly(count)) +fun LootPool.Builder.setRolls(min: Int, max: Int): LootPool.Builder = setRolls( + UniformGenerator.between( + min.toFloat(), + max.toFloat() + ) +) +fun LootPool.Builder.setRolls(min: Float, max: Float): LootPool.Builder = setRolls(UniformGenerator.between(min, max)) +fun LootPool.Builder.condition(value: LootItemCondition.Builder): LootPool.Builder = `when`(value) +fun LootPool.Builder.chanceCondition(chance: Double): LootPool.Builder = condition(ChanceCondition(chance)) +fun > T.setCount(count: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { + apply(SetItemCountFunction.setCount(ConstantValue.exactly(count.toFloat())).also(configurator)) + return this +} + +fun > T.setCount(minimal: Int, maximal: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { + apply(SetItemCountFunction.setCount(UniformGenerator.between(minimal.toFloat(), maximal.toFloat())).also(configurator)) + return this +} + +fun > T.setCount(minimal: Float, maximal: Float, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { + apply(SetItemCountFunction.setCount(UniformGenerator.between(minimal, maximal)).also(configurator)) + return this +} + +fun > T.condition(condition: LootItemCondition.Builder): T { + `when`(condition) + return this +} + +fun > T.condition(condition: LootItemCondition.Builder): T { + `when`(condition) + return this +} + +inline fun > T.blockStateCondition(block: Block, configurator: StatePropertiesPredicate.Builder.() -> Unit): T { + condition( + LootItemBlockStatePropertyCondition.hasBlockStateProperties(block) + .setProperties(StatePropertiesPredicate.Builder.properties().also(configurator))) + return this +} + +inline fun > T.blockStateCondition(block: Block, configurator: StatePropertiesPredicate.Builder.() -> Unit): T { + condition( + LootItemBlockStatePropertyCondition.hasBlockStateProperties(block) + .setProperties(StatePropertiesPredicate.Builder.properties().also(configurator))) + return this +} + +fun > T.chanceCondition(chance: Double): T { + condition(ChanceCondition(chance)) + return this +} + +operator fun StatePropertiesPredicate.Builder.set(property: Property<*>, value: String): StatePropertiesPredicate.Builder = hasProperty(property, value) +operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Int): StatePropertiesPredicate.Builder = hasProperty(property, value) +operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Boolean): StatePropertiesPredicate.Builder = hasProperty(property, value) +operator fun > StatePropertiesPredicate.Builder.set(property: Property, value: T): StatePropertiesPredicate.Builder { + if (value !is StringRepresentable) { + throw ClassCastException("Provided type ${value::class.qualifiedName} is not a subtype of ${StringRepresentable::class.qualifiedName}") + } + + return hasProperty(property, value.serializedName) +} diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt index 9802d961f..a88abc8cb 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt @@ -10,30 +10,23 @@ import net.minecraft.advancements.critereon.StatePropertiesPredicate import net.minecraft.data.DataGenerator import net.minecraft.data.loot.LootTableProvider import net.minecraft.resources.ResourceLocation -import net.minecraft.util.StringRepresentable import net.minecraft.world.level.ItemLike import net.minecraft.world.level.block.Block import net.minecraft.world.level.block.SlabBlock -import net.minecraft.world.level.block.state.properties.Property import net.minecraft.world.level.block.state.properties.SlabType import net.minecraft.world.level.storage.loot.LootPool import net.minecraft.world.level.storage.loot.LootTable import net.minecraft.world.level.storage.loot.ValidationContext import net.minecraft.world.level.storage.loot.entries.LootItem -import net.minecraft.world.level.storage.loot.entries.LootPoolSingletonContainer import net.minecraft.world.level.storage.loot.functions.CopyNbtFunction -import net.minecraft.world.level.storage.loot.functions.LootItemConditionalFunction import net.minecraft.world.level.storage.loot.functions.SetItemCountFunction import net.minecraft.world.level.storage.loot.parameters.LootContextParamSet import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets import net.minecraft.world.level.storage.loot.predicates.LootItemBlockStatePropertyCondition -import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.providers.nbt.ContextNbtProvider import net.minecraft.world.level.storage.loot.providers.number.ConstantValue -import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity import ru.dbotthepony.mc.otm.block.entity.MatteryWorkerBlockEntity -import ru.dbotthepony.mc.otm.data.condition.ChanceCondition import java.util.function.BiConsumer import java.util.function.Consumer import java.util.function.Supplier @@ -43,73 +36,6 @@ private typealias LootTableCallback = Consumer private typealias LootTableCallbackProvider = Supplier private typealias LootTuple = Pair -inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool(LootPool.lootPool().also(configurator)) -inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool.Builder = LootPool.lootPool().also(configurator) - -inline fun LootPool.Builder.item(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit) { - add(LootItem.lootTableItem(item).also(configurator)) -} - -fun LootPool.Builder.setRolls(count: Int): LootPool.Builder = setRolls(ConstantValue.exactly(count.toFloat())) -fun LootPool.Builder.setRolls(count: Float): LootPool.Builder = setRolls(ConstantValue.exactly(count)) - -fun LootPool.Builder.setRolls(min: Int, max: Int): LootPool.Builder = setRolls(UniformGenerator.between(min.toFloat(), max.toFloat())) -fun LootPool.Builder.setRolls(min: Float, max: Float): LootPool.Builder = setRolls(UniformGenerator.between(min, max)) - -fun LootPool.Builder.condition(value: LootItemCondition.Builder): LootPool.Builder = `when`(value) -fun LootPool.Builder.chanceCondition(chance: Double): LootPool.Builder = condition(ChanceCondition(chance)) - -fun > T.setCount(count: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { - apply(SetItemCountFunction.setCount(ConstantValue.exactly(count.toFloat())).also(configurator)) - return this -} - -fun > T.setCount(minimal: Int, maximal: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { - apply(SetItemCountFunction.setCount(UniformGenerator.between(minimal.toFloat(), maximal.toFloat())).also(configurator)) - return this -} - -fun > T.setCount(minimal: Float, maximal: Float, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { - apply(SetItemCountFunction.setCount(UniformGenerator.between(minimal, maximal)).also(configurator)) - return this -} - -fun > T.condition(condition: LootItemCondition.Builder): T { - `when`(condition) - return this -} - -fun > T.condition(condition: LootItemCondition.Builder): T { - `when`(condition) - return this -} - -inline fun > T.blockStateCondition(block: Block, configurator: StatePropertiesPredicate.Builder.() -> Unit): T { - condition(LootItemBlockStatePropertyCondition.hasBlockStateProperties(block).setProperties(StatePropertiesPredicate.Builder.properties().also(configurator))) - return this -} - -inline fun > T.blockStateCondition(block: Block, configurator: StatePropertiesPredicate.Builder.() -> Unit): T { - condition(LootItemBlockStatePropertyCondition.hasBlockStateProperties(block).setProperties(StatePropertiesPredicate.Builder.properties().also(configurator))) - return this -} - -fun > T.chanceCondition(chance: Double): T { - condition(ChanceCondition(chance)) - return this -} - -operator fun StatePropertiesPredicate.Builder.set(property: Property<*>, value: String): StatePropertiesPredicate.Builder = hasProperty(property, value) -operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Int): StatePropertiesPredicate.Builder = hasProperty(property, value) -operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Boolean): StatePropertiesPredicate.Builder = hasProperty(property, value) -operator fun > StatePropertiesPredicate.Builder.set(property: Property, value: T): StatePropertiesPredicate.Builder { - if (value !is StringRepresentable) { - throw ClassCastException("Provided type ${value::class.qualifiedName} is not a subtype of ${StringRepresentable::class.qualifiedName}") - } - - return hasProperty(property, value.serializedName) -} - data class NbtCopy(val source: String, val destination: String, val strategy: CopyNbtFunction.MergeStrategy = CopyNbtFunction.MergeStrategy.REPLACE) fun TileNbtCopy(source: String, strategy: CopyNbtFunction.MergeStrategy = CopyNbtFunction.MergeStrategy.REPLACE): NbtCopy { From 228cc3eab5704b42cc81cfecc635d2aa62afb387 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 14:23:14 +0700 Subject: [PATCH 18/21] un-funny format --- .../ru/dbotthepony/mc/otm/datagen/loot/DSL.kt | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt index a1877e520..c8e3aacf3 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt @@ -17,24 +17,22 @@ import net.minecraft.world.level.storage.loot.providers.number.ConstantValue import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator import ru.dbotthepony.mc.otm.data.condition.ChanceCondition -inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool( - LootPool.lootPool().also(configurator)) +inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool(LootPool.lootPool().also(configurator)) + inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool.Builder = LootPool.lootPool().also(configurator) + inline fun LootPool.Builder.item(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit) { add(LootItem.lootTableItem(item).also(configurator)) } fun LootPool.Builder.setRolls(count: Int): LootPool.Builder = setRolls(ConstantValue.exactly(count.toFloat())) fun LootPool.Builder.setRolls(count: Float): LootPool.Builder = setRolls(ConstantValue.exactly(count)) -fun LootPool.Builder.setRolls(min: Int, max: Int): LootPool.Builder = setRolls( - UniformGenerator.between( - min.toFloat(), - max.toFloat() - ) -) +fun LootPool.Builder.setRolls(min: Int, max: Int): LootPool.Builder = setRolls(UniformGenerator.between(min.toFloat(), max.toFloat())) fun LootPool.Builder.setRolls(min: Float, max: Float): LootPool.Builder = setRolls(UniformGenerator.between(min, max)) + fun LootPool.Builder.condition(value: LootItemCondition.Builder): LootPool.Builder = `when`(value) fun LootPool.Builder.chanceCondition(chance: Double): LootPool.Builder = condition(ChanceCondition(chance)) + fun > T.setCount(count: Int, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { apply(SetItemCountFunction.setCount(ConstantValue.exactly(count.toFloat())).also(configurator)) return this @@ -82,6 +80,7 @@ fun > T.chanceCondition(chance: Doubl operator fun StatePropertiesPredicate.Builder.set(property: Property<*>, value: String): StatePropertiesPredicate.Builder = hasProperty(property, value) operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Int): StatePropertiesPredicate.Builder = hasProperty(property, value) operator fun StatePropertiesPredicate.Builder.set(property: Property, value: Boolean): StatePropertiesPredicate.Builder = hasProperty(property, value) + operator fun > StatePropertiesPredicate.Builder.set(property: Property, value: T): StatePropertiesPredicate.Builder { if (value !is StringRepresentable) { throw ClassCastException("Provided type ${value::class.qualifiedName} is not a subtype of ${StringRepresentable::class.qualifiedName}") From 4dc132a8ec1e04b9f219ae41c452009714d0d6aa Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 15:57:35 +0700 Subject: [PATCH 19/21] Move everything to lootpools Fixes #191 --- .../ru/dbotthepony/mc/otm/datagen/loot/DSL.kt | 26 ++- .../mc/otm/datagen/loot/LootModifiers.kt | 4 +- .../mc/otm/datagen/loot/LootModifiersData.kt | 94 +++++---- .../condition/ChanceWithPlaytimeCondition.kt | 1 + .../otm/data/condition/HasExosuitCondition.kt | 1 + .../condition/ItemInInventoryCondition.kt | 1 + .../otm/data/condition/KilledByRealPlayer.kt | 1 + .../KilledByRealPlayerOrIndirectly.kt | 1 + .../mc/otm/data/loot/IRandomizableItem.kt | 2 +- .../mc/otm/data/loot/LootPoolAppender.kt | 31 ++- .../data/loot/RandomizableItemLootAppender.kt | 189 ------------------ .../mc/otm/data/loot/RandomizerFunction.kt | 81 ++++++++ .../mc/otm/registry/LootModifiers.kt | 2 - .../mc/otm/registry/MItemFunctionTypes.kt | 19 ++ .../dbotthepony/mc/otm/registry/MRegistry.kt | 1 + 15 files changed, 205 insertions(+), 249 deletions(-) delete mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt create mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizerFunction.kt create mode 100644 src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItemFunctionTypes.kt diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt index c8e3aacf3..4ca29433b 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/DSL.kt @@ -2,6 +2,7 @@ package ru.dbotthepony.mc.otm.datagen.loot import net.minecraft.advancements.critereon.StatePropertiesPredicate import net.minecraft.util.StringRepresentable +import net.minecraft.world.item.Rarity import net.minecraft.world.level.ItemLike import net.minecraft.world.level.block.Block import net.minecraft.world.level.block.state.properties.Property @@ -16,10 +17,28 @@ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.providers.number.ConstantValue import net.minecraft.world.level.storage.loot.providers.number.UniformGenerator import ru.dbotthepony.mc.otm.data.condition.ChanceCondition +import ru.dbotthepony.mc.otm.data.loot.RandomizerFunction inline fun LootTable.Builder.lootPool(configurator: LootPool.Builder.() -> Unit): LootTable.Builder = withPool(LootPool.lootPool().also(configurator)) +inline fun LootTable.Builder.singleItem(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit): LootTable.Builder { + return withPool(LootPool.lootPool().also { + it.item(item, configurator) + }) +} -inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool.Builder = LootPool.lootPool().also(configurator) +inline fun lootPool(configurator: LootPool.Builder.() -> Unit): LootPool = LootPool.lootPool().also(configurator).build() +inline fun singleItem(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit): LootPool = lootPool { item(item, configurator) } +fun singleRandomizedItem(item: ItemLike, rarity: Rarity = Rarity.COMMON, chance: Double? = null): LootPool { + return lootPool { + item(item) { + apply(RandomizerFunction.valueOf(rarity)) + + if (chance != null) { + chanceCondition(chance) + } + } + } +} inline fun LootPool.Builder.item(item: ItemLike, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit) { add(LootItem.lootTableItem(item).also(configurator)) @@ -43,6 +62,11 @@ fun > T.setCount(minimal: Int, maximal return this } +fun > T.chanceCondition(chance: Double): T { + condition(ChanceCondition(chance)) + return this +} + fun > T.setCount(minimal: Float, maximal: Float, configurator: LootItemConditionalFunction.Builder<*>.() -> Unit = {}): T { apply(SetItemCountFunction.setCount(UniformGenerator.between(minimal, maximal)).also(configurator)) return this diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt index 77a42d003..cc119d648 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiers.kt @@ -19,7 +19,7 @@ fun BasicLootAppender( item(it.item) { setCount(it.count) } - }.build() + } }) } @@ -41,7 +41,7 @@ fun PlainLootAppender( } chanceCondition(it.second) - }.build() + } }) } diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt index adcff7df2..7751c5a1e 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootModifiersData.kt @@ -6,13 +6,14 @@ import net.minecraft.world.item.ItemStack import net.minecraft.world.item.Rarity import net.minecraft.world.level.storage.loot.BuiltInLootTables import net.minecraft.world.level.storage.loot.predicates.LootItemCondition +import net.minecraftforge.common.loot.LootModifier import net.minecraftforge.common.loot.LootTableIdCondition import ru.dbotthepony.mc.otm.data.condition.ChanceWithPlaytimeCondition import ru.dbotthepony.mc.otm.data.condition.HasExosuitCondition -import ru.dbotthepony.mc.otm.data.loot.IRandomizableItem import ru.dbotthepony.mc.otm.data.condition.ItemInInventoryCondition import ru.dbotthepony.mc.otm.data.condition.KilledByRealPlayerOrIndirectly -import ru.dbotthepony.mc.otm.data.loot.RandomizableItemLootAppender +import ru.dbotthepony.mc.otm.data.loot.LootPoolAppender +import ru.dbotthepony.mc.otm.data.loot.RandomizerFunction import ru.dbotthepony.mc.otm.registry.MItems @Suppress("FunctionName") @@ -25,7 +26,50 @@ fun LootTableIdCondition(location: ResourceLocation): LootItemCondition { return LootTableIdCondition.Builder(location).build() } +private fun exosuitModifiers(it: LootModifiers) { + it.add("dungeon_exosuit", LootPoolAppender( + arrayOf(LootTableIdCondition(BuiltInLootTables.SIMPLE_DUNGEON)), + + singleItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL) { + chanceCondition(0.2) + apply(RandomizerFunction.COMMON) + }, + + singleItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL) { + chanceCondition(0.05) + apply(RandomizerFunction.UNCOMMON) + }, + )) + + it.add("mineshaft_exosuit", LootPoolAppender( + arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.1), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.1, rarity = Rarity.UNCOMMON) + )) + + it.add("desert_pyramid_exosuit", LootPoolAppender( + arrayOf(LootTableIdCondition(BuiltInLootTables.DESERT_PYRAMID)), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.15, rarity = Rarity.UNCOMMON), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.25, rarity = Rarity.COMMON) + )) + + it.add("jungle_temple_exosuit", LootPoolAppender( + arrayOf(LootTableIdCondition(BuiltInLootTables.JUNGLE_TEMPLE)), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.15, rarity = Rarity.UNCOMMON), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.35, rarity = Rarity.RARE) + )) + + it.add("end_city_exosuit", LootPoolAppender( + arrayOf(LootTableIdCondition(BuiltInLootTables.END_CITY_TREASURE)), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.4, rarity = Rarity.UNCOMMON), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.2, rarity = Rarity.RARE), + singleRandomizedItem(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL, chance = 0.15, rarity = Rarity.EPIC), + )) +} + fun addLootModifiers(it: LootModifiers) { + exosuitModifiers(it) + it.add("dungeon_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.SIMPLE_DUNGEON)), ItemStack(MItems.PILL_ANDROID, 1) to 0.4, @@ -33,15 +77,6 @@ fun addLootModifiers(it: LootModifiers) { ItemStack(MItems.PILL_HEAL, 1) to 0.75, )) - it.add("dungeon_exosuit", RandomizableItemLootAppender( - arrayOf(LootTableIdCondition(BuiltInLootTables.SIMPLE_DUNGEON)), - listOf( - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.2), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.05, rarity = Rarity.UNCOMMON) - ) - ) - ) - it.add("mineshaft_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), ItemStack(MItems.PILL_ANDROID, 1) to 0.075, @@ -49,15 +84,6 @@ fun addLootModifiers(it: LootModifiers) { ItemStack(MItems.PILL_HEAL, 1) to 0.4, )) - it.add("mineshaft_exosuit", RandomizableItemLootAppender( - arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), - listOf( - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.1), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.01, rarity = Rarity.UNCOMMON) - ) - ) - ) - it.add("mineshaft_nutrient_paste", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.ABANDONED_MINESHAFT)), ItemStack(MItems.NUTRIENT_PASTE, 6) to 0.5, @@ -71,29 +97,11 @@ fun addLootModifiers(it: LootModifiers) { ItemStack(MItems.PILL_HEAL, 1) to 0.3, )) - it.add("desert_pyramid_exosuit", RandomizableItemLootAppender( - arrayOf(LootTableIdCondition(BuiltInLootTables.DESERT_PYRAMID)), - listOf( - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.UNCOMMON), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.25, rarity = Rarity.COMMON), - ) - ) - ) - it.add("jungle_temple_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.JUNGLE_TEMPLE)), ItemStack(MItems.PILL_ANDROID, 1) to 0.5 )) - it.add("jungle_temple_exosuit", RandomizableItemLootAppender( - arrayOf(LootTableIdCondition(BuiltInLootTables.JUNGLE_TEMPLE)), - listOf( - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.UNCOMMON), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.35, rarity = Rarity.RARE) - ) - ) - ) - it.add("end_city_modifications", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.END_CITY_TREASURE)), ItemStack(MItems.PILL_ANDROID, 1) to 0.1, @@ -102,16 +110,6 @@ fun addLootModifiers(it: LootModifiers) { ItemStack(MItems.ZPM_BATTERY, 1) to 0.005, )) - it.add("end_city_exosuit", RandomizableItemLootAppender( - arrayOf(LootTableIdCondition(BuiltInLootTables.END_CITY_TREASURE)), - listOf( - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.4, rarity = Rarity.UNCOMMON), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.2, rarity = Rarity.RARE), - RandomizableItemLootAppender.Entry(MItems.ExosuitUpgrades.INVENTORY_UPGRADE_PROCEDURAL as IRandomizableItem, chance = 0.15, rarity = Rarity.EPIC), - ) - ) - ) - it.add("shipwreck_supply_pill", PlainLootAppender( arrayOf(LootTableIdCondition(BuiltInLootTables.SHIPWRECK_SUPPLY)), ItemStack(MItems.PILL_HUMANE, 1) to 0.4, diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt index af1e4118b..bcfee2b3d 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ChanceWithPlaytimeCondition.kt @@ -11,6 +11,7 @@ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import ru.dbotthepony.mc.otm.capability.matteryPlayer import ru.dbotthepony.mc.otm.core.set +import ru.dbotthepony.mc.otm.data.get import ru.dbotthepony.mc.otm.registry.MLootItemConditions data class ChanceWithPlaytimeCondition( diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt index 69c5b158e..d05663c51 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/HasExosuitCondition.kt @@ -10,6 +10,7 @@ import net.minecraft.world.level.storage.loot.predicates.InvertedLootItemConditi import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import ru.dbotthepony.mc.otm.capability.matteryPlayer +import ru.dbotthepony.mc.otm.data.get import ru.dbotthepony.mc.otm.registry.MLootItemConditions object HasExosuitCondition : LootItemCondition, Serializer, LootItemCondition.Builder { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt index fbad4de61..39dc2ef2c 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/ItemInInventoryCondition.kt @@ -17,6 +17,7 @@ import net.minecraftforge.registries.ForgeRegistries import ru.dbotthepony.mc.otm.capability.itemsStream import ru.dbotthepony.mc.otm.core.registryName import ru.dbotthepony.mc.otm.core.set +import ru.dbotthepony.mc.otm.data.get import ru.dbotthepony.mc.otm.registry.MLootItemConditions data class ItemInInventoryCondition( diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt index 642d14ce9..d4354c2a7 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayer.kt @@ -10,6 +10,7 @@ import net.minecraft.world.level.storage.loot.predicates.InvertedLootItemConditi import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import net.minecraftforge.common.util.FakePlayer +import ru.dbotthepony.mc.otm.data.get import ru.dbotthepony.mc.otm.registry.MLootItemConditions object KilledByRealPlayer : LootItemCondition, Serializer, LootItemCondition.Builder { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt index e08b59e5a..df3d9dd14 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/condition/KilledByRealPlayerOrIndirectly.kt @@ -12,6 +12,7 @@ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType import net.minecraftforge.common.util.FakePlayer import ru.dbotthepony.mc.otm.NULLABLE_MINECRAFT_SERVER +import ru.dbotthepony.mc.otm.data.get import ru.dbotthepony.mc.otm.registry.MLootItemConditions object KilledByRealPlayerOrIndirectly : LootItemCondition, Serializer, LootItemCondition.Builder { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt index 42ba6ca86..b649659ac 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/IRandomizableItem.kt @@ -6,6 +6,6 @@ import net.minecraft.world.item.ItemStack import net.minecraft.world.item.Rarity import net.minecraft.world.level.ItemLike -interface IRandomizableItem : ItemLike { +interface IRandomizableItem { fun randomize(itemStack: ItemStack, random: RandomSource, ply: Player?, rarity: Rarity = Rarity.COMMON) } diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt index fea33bfb0..487b6d274 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/LootPoolAppender.kt @@ -8,14 +8,17 @@ import com.mojang.serialization.Dynamic import com.mojang.serialization.JsonOps import com.mojang.serialization.codecs.RecordCodecBuilder import it.unimi.dsi.fastutil.objects.ObjectArrayList +import net.minecraft.resources.ResourceLocation import net.minecraft.world.item.ItemStack import net.minecraft.world.level.storage.loot.Deserializers import net.minecraft.world.level.storage.loot.LootContext import net.minecraft.world.level.storage.loot.LootPool import net.minecraft.world.level.storage.loot.predicates.LootItemCondition +import net.minecraftforge.common.ForgeHooks import net.minecraftforge.common.loot.IGlobalLootModifier import net.minecraftforge.common.loot.LootModifier import java.util.Arrays +import java.util.Deque import java.util.stream.Stream class LootPoolAppender(conditions: Array, pools: Stream) : LootModifier(conditions) { @@ -36,23 +39,39 @@ class LootPoolAppender(conditions: Array, pools: Stream): JsonElement { - val value = it.value ?: throw NullPointerException("value was null") - return value as? JsonElement ?: it.ops.convertTo(JsonOps.INSTANCE, it) + private val lootPoolCodec: Codec> + + private val forgeHooksLootContext by lazy { + val field = ForgeHooks::class.java.getDeclaredField("lootContext") + field.isAccessible = true + field } - private val lootPoolCodec: Codec> + private val lootTableContextConstructor by lazy { + val clazz = ForgeHooks::class.java.declaredClasses.firstOrNull { it.name.contains("LootTableContext") } ?: throw NoSuchElementException("Unable to find ForgeHooks\$LootTableContext!") + val constructor = clazz.getDeclaredConstructor(ResourceLocation::class.java, Boolean::class.java) + constructor.isAccessible = true + constructor + } init { val serializer = Deserializers.createLootTableSerializer().create() + val notExistingLocation = ResourceLocation("null", "null") lootPoolCodec = Codec.list(Codec.PASSTHROUGH.flatXmap({ + val dequeueHolder = forgeHooksLootContext.get(null) as ThreadLocal> + val deque = dequeueHolder.get() ?: java.util.ArrayDeque() + dequeueHolder.set(deque) + try { - DataResult.success(serializer.fromJson(getJson(it as Dynamic), LootPool::class.java)) + deque.push(lootTableContextConstructor.newInstance(notExistingLocation, true)) + DataResult.success(serializer.fromJson(it.convert(JsonOps.INSTANCE).value, LootPool::class.java)) } catch(err: JsonSyntaxException) { DataResult.error(err.message) + } finally { + deque.pop() } }, { try { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt deleted file mode 100644 index d78cbc834..000000000 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizableItemLootAppender.kt +++ /dev/null @@ -1,189 +0,0 @@ -package ru.dbotthepony.mc.otm.data.loot - -import com.google.common.collect.ImmutableList -import com.mojang.datafixers.util.Pair -import com.mojang.serialization.Codec -import com.mojang.serialization.DataResult -import com.mojang.serialization.DynamicOps -import com.mojang.serialization.codecs.RecordCodecBuilder -import it.unimi.dsi.fastutil.objects.ObjectArrayList -import net.minecraft.util.valueproviders.ConstantInt -import net.minecraft.util.valueproviders.IntProvider -import net.minecraft.world.entity.player.Player -import net.minecraft.world.item.Item -import net.minecraft.world.item.ItemStack -import net.minecraft.world.item.Rarity -import net.minecraft.world.level.storage.loot.LootContext -import net.minecraft.world.level.storage.loot.parameters.LootContextParams -import net.minecraft.world.level.storage.loot.predicates.LootItemCondition -import net.minecraftforge.common.loot.LootModifier -import net.minecraftforge.registries.ForgeRegistries -import ru.dbotthepony.mc.otm.data.codec - -class RandomizableItemLootAppender( - conditions: Array, - entries: Collection -) : LootModifier(conditions) { - data class Entry( - val item: IRandomizableItem, - val chance: Double, - val count: IntProvider = ConstantInt.of(1), - val rarity: Rarity = Rarity.COMMON, - val distinct: Boolean = true, - ) { - constructor( - item: IRandomizableItem, - chance: Double, - count: Int, - rarity: Rarity = Rarity.COMMON, - distinct: Boolean = true, - ) : this(item, chance, ConstantInt.of(count), rarity, distinct) - - private constructor( - item: Item, - chance: Double, - count: IntProvider, - rarity: Rarity = Rarity.COMMON, - distinct: Boolean = true, - ) : this(item as? IRandomizableItem ?: throw ClassCastException("$item is not a subtype of IRandomizableItem"), chance, count, rarity, distinct) - - init { - require(count.minValue >= 0) { "Invalid min value ${count.minValue}" } - require(count.maxValue >= 0) { "Invalid max value ${count.maxValue}" } - require(count.maxValue >= count.minValue) { "Invalid bounds, they must be ${count.maxValue} >= ${count.minValue}!" } - } - - companion object { - val CODEC: Codec by lazy { - RecordCodecBuilder.create { - it.group( - ForgeRegistries.ITEMS.codec.fieldOf("item").forGetter { it.item.asItem() }, - Codec.DOUBLE.fieldOf("chance").forGetter(Entry::chance), - IntProvider.CODEC.fieldOf("count").forGetter(Entry::count), - Rarity::class.codec().fieldOf("rarity").forGetter(Entry::rarity), - Codec.BOOL.fieldOf("distinct").forGetter(Entry::distinct), - ).apply(it, RandomizableItemLootAppender::Entry) - } - } - } - } - - val entries: List = ImmutableList.copyOf(entries) - - override fun codec(): Codec { - return Companion - } - - override fun doApply( - generatedLoot: ObjectArrayList, - context: LootContext - ): ObjectArrayList { - val random = context.random - - val player = - context.getParamOrNull(LootContextParams.DIRECT_KILLER_ENTITY).let { - if (it != null) - it as? Player - else - context.getParamOrNull(LootContextParams.KILLER_ENTITY).let { - if (it != null) - it as? Player - else - context.getParamOrNull(LootContextParams.THIS_ENTITY) as? Player - } - } - - for ((item, chance, count, rarity, distinct) in entries) { - if (random.nextDouble() <= chance) { - if (distinct) { - val items = ArrayList() - - for (i in 0 until count.sample(random)) { - val stack = ItemStack(item.asItem(), 1) - item.randomize(stack, random, player, rarity) - - for (existing in items) { - if (ItemStack.isSameItemSameTags(existing, stack)) { - existing.count += stack.count - stack.count = 0 - break - } - } - - if (stack.count > 0) { - items.add(stack) - } - } - - for (stack in items) { - while (stack.count > stack.maxStackSize && stack.maxStackSize > 0) { - val split = stack.split(stack.maxStackSize) - generatedLoot.add(split) - } - - generatedLoot.add(stack) - } - } else { - val stack = ItemStack(item.asItem(), count.sample(random)) - item.randomize(stack, random, player, rarity) - - while (stack.count > stack.maxStackSize && stack.maxStackSize > 0) { - val split = stack.split(stack.maxStackSize) - generatedLoot.add(split) - } - - generatedLoot.add(stack) - } - } - } - - return generatedLoot - } - - companion object : Codec { - override fun encode( - input: RandomizableItemLootAppender, - ops: DynamicOps, - prefix: T - ): DataResult { - require(prefix == ops.empty()) { "Non-empty prefix: $prefix" } - - return LOOT_CONDITIONS_CODEC.encode(input.conditions, ops, prefix).flatMap map@{ - val encodedEntries = input.entries.map { Entry.CODEC.encode(it, ops, prefix) } - val firstError = encodedEntries.firstOrNull { !it.result().isPresent } - - if (firstError != null) { - return@map firstError - } - - return@map DataResult.success(ops.createMap(linkedMapOf( - ops.createString("conditions") to it, - ops.createString("entries") to ops.createList(encodedEntries.stream().map { it.result().get() }) - ))) - } - } - - override fun decode( - ops: DynamicOps, - input: T - ): DataResult> { - return ops.getMap(input).flatMap { map -> - LOOT_CONDITIONS_CODEC.decode(ops, map["conditions"]).flatMap { - val conditions = it.first - - ops.getStream(map["entries"]).flatMap { - val collected = it.map { Entry.CODEC.decode(ops, it) }.toList() - - for ((i, element) in collected.withIndex()) { - if (element.result().isEmpty) { - return@flatMap DataResult.error("Invalid entry at $i: ${element.error().get().message()}") - } - } - - return@flatMap DataResult.success(Pair.of(RandomizableItemLootAppender(conditions, collected.map { it.result().get().first }), ops.empty())) - } - } - } - } - } -} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizerFunction.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizerFunction.kt new file mode 100644 index 000000000..b764464c2 --- /dev/null +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/data/loot/RandomizerFunction.kt @@ -0,0 +1,81 @@ +package ru.dbotthepony.mc.otm.data.loot + +import com.google.gson.JsonDeserializationContext +import com.google.gson.JsonObject +import com.google.gson.JsonPrimitive +import com.google.gson.JsonSerializationContext +import com.google.gson.JsonSyntaxException +import net.minecraft.world.entity.player.Player +import net.minecraft.world.item.ItemStack +import net.minecraft.world.item.Rarity +import net.minecraft.world.level.storage.loot.LootContext +import net.minecraft.world.level.storage.loot.Serializer +import net.minecraft.world.level.storage.loot.functions.LootItemFunction +import net.minecraft.world.level.storage.loot.functions.LootItemFunctionType +import net.minecraft.world.level.storage.loot.parameters.LootContextParams +import org.apache.logging.log4j.LogManager +import ru.dbotthepony.mc.otm.core.set +import ru.dbotthepony.mc.otm.registry.MItemFunctionTypes + +enum class RandomizerFunction(val rarity: Rarity) : LootItemFunction, LootItemFunction.Builder { + COMMON(Rarity.COMMON), + UNCOMMON(Rarity.UNCOMMON), + RARE(Rarity.RARE), + EPIC(Rarity.EPIC); + + override fun apply(itemStack: ItemStack, context: LootContext): ItemStack { + val randomizer = itemStack.item as? IRandomizableItem + + if (randomizer == null) { + LOGGER.error("${itemStack.item} does not implement ${IRandomizableItem::class.qualifiedName}! Can not randomize $itemStack!") + return itemStack + } + + val random = context.random + + val player = + context.getParamOrNull(LootContextParams.DIRECT_KILLER_ENTITY).let { + if (it != null) + it as? Player + else + context.getParamOrNull(LootContextParams.KILLER_ENTITY).let { + if (it != null) + it as? Player + else + context.getParamOrNull(LootContextParams.THIS_ENTITY) as? Player + } + } + + randomizer.randomize(itemStack, random, player, rarity) + return itemStack + } + + override fun getType(): LootItemFunctionType { + return MItemFunctionTypes.RANDOMIZER + } + + override fun build(): LootItemFunction { + return this + } + + companion object : Serializer { + fun valueOf(rarity: Rarity): RandomizerFunction { + return when(rarity) { + Rarity.COMMON -> COMMON + Rarity.UNCOMMON -> UNCOMMON + Rarity.RARE -> RARE + Rarity.EPIC -> EPIC + } + } + + override fun serialize(p_79325_: JsonObject, p_79326_: RandomizerFunction, p_79327_: JsonSerializationContext) { + p_79325_["rarity"] = JsonPrimitive(p_79326_.rarity.name) + } + + override fun deserialize(p_79323_: JsonObject, p_79324_: JsonDeserializationContext): RandomizerFunction { + return valueOf(Rarity.valueOf(p_79323_["rarity"]?.asString ?: throw JsonSyntaxException("Invalid rarity json element"))) + } + + private val LOGGER = LogManager.getLogger() + } +} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt index 4a92c8123..8ae067580 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LootModifiers.kt @@ -5,14 +5,12 @@ import net.minecraftforge.registries.DeferredRegister import net.minecraftforge.registries.ForgeRegistries import ru.dbotthepony.mc.otm.OverdriveThatMatters import ru.dbotthepony.mc.otm.data.loot.LootPoolAppender -import ru.dbotthepony.mc.otm.data.loot.RandomizableItemLootAppender object LootModifiers { private val registry = DeferredRegister.create(ForgeRegistries.Keys.GLOBAL_LOOT_MODIFIER_SERIALIZERS, OverdriveThatMatters.MOD_ID) init { registry.register("loot_appender") { LootPoolAppender.CODEC } - registry.register("randomized_appender") { RandomizableItemLootAppender.Companion } } internal fun register(bus: IEventBus) { diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItemFunctionTypes.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItemFunctionTypes.kt new file mode 100644 index 000000000..f219b1d6b --- /dev/null +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItemFunctionTypes.kt @@ -0,0 +1,19 @@ +package ru.dbotthepony.mc.otm.registry + +import net.minecraft.core.Registry +import net.minecraft.resources.ResourceLocation +import net.minecraft.world.level.storage.loot.functions.LootItemFunctionType +import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType +import net.minecraftforge.registries.RegisterEvent +import ru.dbotthepony.mc.otm.OverdriveThatMatters +import ru.dbotthepony.mc.otm.data.loot.RandomizerFunction + +object MItemFunctionTypes { + val RANDOMIZER = LootItemFunctionType(RandomizerFunction.Companion) + + internal fun register(event: RegisterEvent) { + if (event.getVanillaRegistry() == Registry.LOOT_FUNCTION_TYPE) { + Registry.LOOT_FUNCTION_TYPE.register(ResourceLocation(OverdriveThatMatters.MOD_ID, "randomizer"), RANDOMIZER) + } + } +} diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt index 50a835bb9..cbf2a6e68 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt @@ -262,6 +262,7 @@ object MRegistry { bus.addListener(this::initializeCommon) bus.addListener(MStats::registerVanilla) bus.addListener(MLootItemConditions::register) + bus.addListener(MItemFunctionTypes::register) MBlocks.register(bus) MBlockEntities.register(bus) From 2b50109fd5d982869059b97162503cdca84274ce Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 16:13:57 +0700 Subject: [PATCH 20/21] Check for "survives explosion" Fixes #161 --- .../mc/otm/datagen/loot/LootTables.kt | 27 ++++++-- .../mc/otm/datagen/loot/LootTablesData.kt | 67 ++++++++++--------- 2 files changed, 56 insertions(+), 38 deletions(-) diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt index a88abc8cb..6aa71da6f 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt @@ -18,6 +18,7 @@ import net.minecraft.world.level.storage.loot.LootPool import net.minecraft.world.level.storage.loot.LootTable import net.minecraft.world.level.storage.loot.ValidationContext import net.minecraft.world.level.storage.loot.entries.LootItem +import net.minecraft.world.level.storage.loot.entries.LootPoolSingletonContainer import net.minecraft.world.level.storage.loot.functions.CopyNbtFunction import net.minecraft.world.level.storage.loot.functions.SetItemCountFunction import net.minecraft.world.level.storage.loot.parameters.LootContextParamSet @@ -93,7 +94,7 @@ class LootTables(generator: DataGenerator) : LootTableProvider(generator) { override fun validate(map: MutableMap, validationtracker: ValidationContext) {} - fun createSlabItemTable(block: Block) { + fun createSlabItemTable(block: Block, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit = {}) { builder(LootContextParamSets.BLOCK, block.lootTable) { withPool( LootPool.lootPool().setRolls(ConstantValue.exactly(1.0f)).add( @@ -106,14 +107,16 @@ class LootTables(generator: DataGenerator) : LootTableProvider(generator) { .hasProperty(SlabBlock.TYPE, SlabType.DOUBLE) ) ) - ) + ).also(configurator) ) ) } } - fun createSlabItemTable(block: Collection) { - block.forEach(this::createSlabItemTable) + fun createSlabItemTable(blocks: Collection, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit = {}) { + for (block in blocks) { + createSlabItemTable(block, configurator) + } } fun blockProvider(block: Block, provider: () -> LootTable.Builder) { @@ -141,13 +144,23 @@ class LootTables(generator: DataGenerator) : LootTableProvider(generator) { fun dropsSelf(vararg blocks: Block) { for (block in blocks) { singleLootPool(LootContextParamSets.BLOCK, block.lootTable) { - add(LootItem.lootTableItem(block)) + item(block) {} } } } - fun dropsSelf(blocks: Collection) { - blocks.forEach(this::dropsSelf) + fun dropsSelf(block: Block, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit = {}) { + singleLootPool(LootContextParamSets.BLOCK, block.lootTable) { + item(block, configurator) + } + } + + fun dropsSelf(blocks: Collection, configurator: LootPoolSingletonContainer.Builder<*>.() -> Unit = {}) { + for (block in blocks) { + singleLootPool(LootContextParamSets.BLOCK, block.lootTable) { + item(block, configurator) + } + } } fun tile(block: Block, f: (CopyNbtFunction.Builder) -> Unit = {}) { diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTablesData.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTablesData.kt index 651c175d4..2a921f87b 100644 --- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTablesData.kt +++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTablesData.kt @@ -7,6 +7,7 @@ import net.minecraft.world.level.block.state.properties.BlockStateProperties import net.minecraft.world.level.block.state.properties.DoubleBlockHalf import net.minecraft.world.level.storage.loot.entries.LootItem import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets +import net.minecraft.world.level.storage.loot.predicates.ExplosionCondition import ru.dbotthepony.mc.otm.block.entity.ChemicalGeneratorBlockEntity import ru.dbotthepony.mc.otm.block.entity.EnergyCounterBlockEntity import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.ENERGY_KEY @@ -22,45 +23,45 @@ import ru.dbotthepony.mc.otm.registry.MItems import ru.dbotthepony.mc.otm.registry.MRegistry fun addLootTables(lootTables: LootTables) { - lootTables.dropsSelf(MRegistry.DECORATIVE_CRATE.allBlocks.values) + lootTables.dropsSelf(MRegistry.DECORATIVE_CRATE.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } - lootTables.dropsSelf(MRegistry.CARGO_CRATES.allBlocks.values) - lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS.allBlocks.values) - lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS_PANE.allBlocks.values) - lootTables.dropsSelf(MRegistry.TRITANIUM_BLOCK.allBlocks.values) - lootTables.dropsSelf(MRegistry.TRITANIUM_WALL.allBlocks.values) - lootTables.dropsSelf(MRegistry.TRITANIUM_STAIRS.allBlocks.values) + lootTables.dropsSelf(MRegistry.CARGO_CRATES.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS_PANE.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_BLOCK.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_WALL.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_STAIRS.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } lootTables.createSlabItemTable(MRegistry.TRITANIUM_SLAB.allBlocks.values) - lootTables.dropsSelf(MRegistry.VENT.allBlocks.values) - lootTables.dropsSelf(MRegistry.VENT_ALTERNATIVE.allBlocks.values) - lootTables.dropsSelf(MRegistry.FLOOR_TILES.blocks.values) - lootTables.dropsSelf(MRegistry.UNREFINED_FLOOR_TILES.blocks.values) - lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_BLOCK.flatBlocks) - lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_STAIRS.flatBlocks) - lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_WALL.flatBlocks) - lootTables.createSlabItemTable(MRegistry.TRITANIUM_STRIPED_SLAB.flatBlocks) + lootTables.dropsSelf(MRegistry.VENT.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.VENT_ALTERNATIVE.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.FLOOR_TILES.blocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.UNREFINED_FLOOR_TILES.blocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_BLOCK.flatBlocks) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_STAIRS.flatBlocks) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_WALL.flatBlocks) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.createSlabItemTable(MRegistry.TRITANIUM_STRIPED_SLAB.flatBlocks) { condition(ExplosionCondition.survivesExplosion()) } - lootTables.dropsSelf(MRegistry.FLOOR_TILES_STAIRS.blocks.values) - lootTables.createSlabItemTable(MRegistry.FLOOR_TILES_SLAB.blocks.values) + lootTables.dropsSelf(MRegistry.FLOOR_TILES_STAIRS.blocks.values) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.createSlabItemTable(MRegistry.FLOOR_TILES_SLAB.blocks.values) { condition(ExplosionCondition.survivesExplosion()) } - lootTables.dropsSelf(MBlocks.CARBON_FIBRE_BLOCK) - lootTables.dropsSelf(MBlocks.TRITANIUM_RAW_BLOCK) - lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_BLOCK) - lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_WALL) - lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_STAIRS) - lootTables.createSlabItemTable(MBlocks.TRITANIUM_STRIPED_SLAB) - lootTables.dropsSelf(MBlocks.MATTER_CABLE) + lootTables.dropsSelf(MBlocks.CARBON_FIBRE_BLOCK) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.TRITANIUM_RAW_BLOCK) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_BLOCK) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_WALL) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.TRITANIUM_STRIPED_STAIRS) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.createSlabItemTable(MBlocks.TRITANIUM_STRIPED_SLAB) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.MATTER_CABLE) { condition(ExplosionCondition.survivesExplosion()) } lootTables.dropsSelf(MBlocks.GRAVITATION_STABILIZER) lootTables.dropsOther(MBlocks.GRAVITATION_STABILIZER_LENS, MBlocks.GRAVITATION_STABILIZER) - lootTables.dropsSelf(MBlocks.LABORATORY_LAMP) - lootTables.dropsSelf(MBlocks.LABORATORY_LAMP_INVERTED) - lootTables.dropsSelf(MBlocks.DANGER_STRIPE_BLOCK) - lootTables.dropsSelf(MBlocks.METAL_BEAM) - lootTables.dropsSelf(MBlocks.TRITANIUM_INGOT_BLOCK) + lootTables.dropsSelf(MBlocks.LABORATORY_LAMP) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.LABORATORY_LAMP_INVERTED) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.DANGER_STRIPE_BLOCK) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.METAL_BEAM) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MBlocks.TRITANIUM_INGOT_BLOCK) { condition(ExplosionCondition.survivesExplosion()) } - lootTables.dropsSelf(MBlocks.TRITANIUM_TRAPDOOR) - lootTables.dropsSelf(MRegistry.TRITANIUM_PRESSURE_PLATE.allBlocks.values) + lootTables.dropsSelf(MBlocks.TRITANIUM_TRAPDOOR) { condition(ExplosionCondition.survivesExplosion()) } + lootTables.dropsSelf(MRegistry.TRITANIUM_PRESSURE_PLATE.allBlocks.values) { condition(ExplosionCondition.survivesExplosion()) } lootTables.block(MBlocks.PHANTOM_ATTRACTOR) { item(MBlocks.PHANTOM_ATTRACTOR) { @@ -68,6 +69,8 @@ fun addLootTables(lootTables: LootTables) { this[BlockStateProperties.DOUBLE_BLOCK_HALF] = DoubleBlockHalf.LOWER } } + + condition(ExplosionCondition.survivesExplosion()) } lootTables.block(MBlocks.TRITANIUM_DOOR) { @@ -76,6 +79,8 @@ fun addLootTables(lootTables: LootTables) { this[BlockStateProperties.DOUBLE_BLOCK_HALF] = DoubleBlockHalf.LOWER } } + + condition(ExplosionCondition.survivesExplosion()) } lootTables.builder(LootContextParamSets.ADVANCEMENT_ENTITY, modLocation("research_all_android")) { From 3ed221afc65b1a305c62a7581bbb929651eb1b51 Mon Sep 17 00:00:00 2001 From: DBotThePony Date: Thu, 27 Oct 2022 17:57:18 +0700 Subject: [PATCH 21/21] Fix glitches rendering incorrectly in water on fancy and fast settings Fixes #211 --- .../ru/dbotthepony/mc/otm/client/render/GlitchRenderer.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/client/render/GlitchRenderer.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/client/render/GlitchRenderer.kt index 875c2cc85..fbcca8a56 100644 --- a/src/main/kotlin/ru/dbotthepony/mc/otm/client/render/GlitchRenderer.kt +++ b/src/main/kotlin/ru/dbotthepony/mc/otm/client/render/GlitchRenderer.kt @@ -19,6 +19,7 @@ import net.minecraft.client.renderer.FogRenderer import net.minecraft.client.renderer.GameRenderer import net.minecraft.core.Vec3i import net.minecraft.world.level.levelgen.XoroshiroRandomSource +import net.minecraft.world.level.material.FogType import org.lwjgl.opengl.GL14 import ru.dbotthepony.mc.otm.ClientConfig import ru.dbotthepony.mc.otm.capability.MatteryPlayerCapability @@ -465,7 +466,7 @@ object GlitchRenderer { makeColorGlitch() } - if (!Minecraft.useShaderTransparency()) { + if (!Minecraft.useShaderTransparency() && minecraft.gameRenderer.mainCamera.fluidInCamera == FogType.NONE) { glitchBuffer.bindWrite(true) RenderSystem.clearColor(FogRenderer.fogRed, FogRenderer.fogGreen, FogRenderer.fogBlue, 1f) RenderSystem.clear(GlConst.GL_COLOR_BUFFER_BIT, Minecraft.ON_OSX)