From 9b06fab9935a1d8df1bf30f81abc4775f78396b5 Mon Sep 17 00:00:00 2001 From: mathi Date: Sun, 23 Nov 2025 15:29:05 +0100 Subject: [PATCH 1/9] Add irradiated biome and associated features, noise settings, and surface rules --- build.gradle | 1 + .../fed443662143001aeb5341375f6f5ef31d10baea | 6 +- .../worldgen/biome/irradiated_plain.json | 48 +++ .../density_function/irradiated/erosion.json | 18 + .../irradiated/final_density.json | 18 + .../noise_settings/irradiated_noise.json | 363 ++++++++++++++++++ .../effects/IrradiationCurseEffect.java | 2 +- .../content/effects/RadiationEffect.java | 19 +- .../content/effects/VicinityEffect.java | 15 +- .../armor/AntiRadiationArmorItem.java | 48 ++- .../multiblock/casing/ReactorCasing.java | 59 ++- .../foundation/events/CommentEvents.java | 24 ++ .../data/GeneratedEntriesProvider.java | 8 + .../worldgen/biome/CNBiomes.java | 55 +++ .../worldgen/biome/CNDensityFunctions.java | 50 +++ .../worldgen/biome/CNNoiseData.java | 33 ++ .../biome/CNNoiseGeneratorSettings.java | 100 +++++ .../worldgen/biome/IrradiatedBiomes.java | 57 +++ .../biome/surfacerule/BiomeTagRule.java | 35 ++ .../surfacerule/IrradiatedSurfaceRules.java | 30 ++ .../surfacerule/IrradiatedSurfaceRules2.java | 91 +++++ .../resources/META-INF/accesstransformer.cfg | 8 + .../resources/createnuclear.forge.mixins.json | 1 + 23 files changed, 1060 insertions(+), 29 deletions(-) create mode 100644 src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json create mode 100644 src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/erosion.json create mode 100644 src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/final_density.json create mode 100644 src/generated/resources/data/createnuclear/worldgen/noise_settings/irradiated_noise.json create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNDensityFunctions.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseData.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseGeneratorSettings.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/BiomeTagRule.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules2.java diff --git a/build.gradle b/build.gradle index ab8ef641..69e0ec49 100644 --- a/build.gradle +++ b/build.gradle @@ -39,6 +39,7 @@ idea { } minecraft { + accessTransformer = file("src/main/resources/META-INF/accesstransformer.cfg") // The mappings can be changed at any time and must be in the following format. // Channel: Version: // official MCVersion Official field/method names from Mojang mapping files diff --git a/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea b/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea index 3fb0164c..5cebb33b 100644 --- a/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea +++ b/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea @@ -1,10 +1,14 @@ -// 1.20.1 2025-11-11T12:39:11.546555 CreateNuclear Generated Registry Entries +// 1.20.1 2025-11-23T12:40:21.151147 CreateNuclear Generated Registry Entries 5edbd74546f4088818e02bb7a5c5eb2ecfe25623 data/createnuclear/forge/biome_modifier/lead_ore.json 72173023e6a31748692e750db0f5fa8c555d1009 data/createnuclear/forge/biome_modifier/striated_ores_overworld.json fa32145101dc12ec914684fec8c5cbb995d2c051 data/createnuclear/forge/biome_modifier/uranium_ore.json +7e7b325ead2c18ad373126b3fed8f2a5b09190e2 data/createnuclear/worldgen/biome/irradiated_plain.json b68555f371c9700aa4ecfa9370b010de8fe25b60 data/createnuclear/worldgen/configured_feature/lead_ore.json 4f11c0a518c0de7857919983fc638ba551c6630a data/createnuclear/worldgen/configured_feature/striated_ores_overworld.json b0e1ee7314412507fd7346cb48b29d105f6186ad data/createnuclear/worldgen/configured_feature/uranium_ore.json +59d61c02881d710b0426a0955f6945b7a12d219f data/createnuclear/worldgen/density_function/irradiated/erosion.json +59d61c02881d710b0426a0955f6945b7a12d219f data/createnuclear/worldgen/density_function/irradiated/final_density.json +0c0e4c64dfa900623b5660f08007b3449a1c67bb data/createnuclear/worldgen/noise_settings/irradiated_noise.json d45ed5f7008864ba4f60c409038ad428a280fd7f data/createnuclear/worldgen/placed_feature/lead_ore.json f26be417cb34461ecb180e77a9a749eaaf4c9880 data/createnuclear/worldgen/placed_feature/striated_ores_overworld.json bed936158c61471513252910d9e3b0e2de610f1a data/createnuclear/worldgen/placed_feature/uranium_ore.json diff --git a/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json new file mode 100644 index 00000000..aa80c921 --- /dev/null +++ b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json @@ -0,0 +1,48 @@ +{ + "carvers": { + "air": "minecraft:nether_cave" + }, + "downfall": 0.0, + "effects": { + "fog_color": 329011, + "mood_sound": { + "block_search_extent": 8, + "offset": 2.0, + "sound": "minecraft:ambient.cave", + "tick_delay": 6000 + }, + "sky_color": 0, + "water_color": 4159204, + "particle": { + "options": { + "type": "minecraft:crimson_spore" + }, + "probability": 0.025 + }, + "water_fog_color": 329011 + }, + "features": [ + [], + [], + [], + [ + "minecraft:blue_ice" + ], + [ + "minecraft:void_start_platform" + ] + ], + "has_precipitation": false, + "spawn_costs": {}, + "spawners": { + "ambient": [], + "axolotls": [], + "creature": [], + "misc": [], + "monster": [], + "underground_water_creature": [], + "water_ambient": [], + "water_creature": [] + }, + "temperature": 2.0 +} \ No newline at end of file diff --git a/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/erosion.json b/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/erosion.json new file mode 100644 index 00000000..feb1cdbd --- /dev/null +++ b/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/erosion.json @@ -0,0 +1,18 @@ +{ + "type": "minecraft:add", + "argument1": { + "type": "minecraft:y_clamped_gradient", + "from_value": 1.0, + "from_y": 0, + "to_value": -1.0, + "to_y": 90 + }, + "argument2": { + "type": "minecraft:old_blended_noise", + "smear_scale_multiplier": 8.0, + "xz_factor": 80.0, + "xz_scale": 0.25, + "y_factor": 160.0, + "y_scale": 0.375 + } +} \ No newline at end of file diff --git a/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/final_density.json b/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/final_density.json new file mode 100644 index 00000000..feb1cdbd --- /dev/null +++ b/src/generated/resources/data/createnuclear/worldgen/density_function/irradiated/final_density.json @@ -0,0 +1,18 @@ +{ + "type": "minecraft:add", + "argument1": { + "type": "minecraft:y_clamped_gradient", + "from_value": 1.0, + "from_y": 0, + "to_value": -1.0, + "to_y": 90 + }, + "argument2": { + "type": "minecraft:old_blended_noise", + "smear_scale_multiplier": 8.0, + "xz_factor": 80.0, + "xz_scale": 0.25, + "y_factor": 160.0, + "y_scale": 0.375 + } +} \ No newline at end of file diff --git a/src/generated/resources/data/createnuclear/worldgen/noise_settings/irradiated_noise.json b/src/generated/resources/data/createnuclear/worldgen/noise_settings/irradiated_noise.json new file mode 100644 index 00000000..34944bbc --- /dev/null +++ b/src/generated/resources/data/createnuclear/worldgen/noise_settings/irradiated_noise.json @@ -0,0 +1,363 @@ +{ + "aquifers_enabled": false, + "default_block": { + "Name": "createnuclear:steel_block" + }, + "default_fluid": { + "Name": "minecraft:air" + }, + "disable_mob_generation": false, + "legacy_random_source": false, + "noise": { + "height": 256, + "min_y": -32, + "size_horizontal": 1, + "size_vertical": 2 + }, + "noise_router": { + "barrier": 1.0, + "continents": "minecraft:overworld/continents", + "depth": "minecraft:overworld/depth", + "erosion": "createnuclear:irradiated/erosion", + "final_density": { + "type": "minecraft:blend_density", + "argument": "createnuclear:irradiated/final_density" + }, + "fluid_level_floodedness": 0.0, + "fluid_level_spread": 0.0, + "initial_density_without_jaggedness": { + "type": "minecraft:add", + "argument1": 0.1171875, + "argument2": { + "type": "minecraft:mul", + "argument1": { + "type": "minecraft:y_clamped_gradient", + "from_value": 0.0, + "from_y": -30, + "to_value": 1.0, + "to_y": -40 + }, + "argument2": { + "type": "minecraft:add", + "argument1": -0.1171875, + "argument2": { + "type": "minecraft:add", + "argument1": -0.078125, + "argument2": { + "type": "minecraft:mul", + "argument1": { + "type": "minecraft:y_clamped_gradient", + "from_value": 1.0, + "from_y": 240, + "to_value": 0.0, + "to_y": 256 + }, + "argument2": { + "type": "minecraft:add", + "argument1": 0.078125, + "argument2": { + "type": "minecraft:clamp", + "input": { + "type": "minecraft:add", + "argument1": -0.703125, + "argument2": { + "type": "minecraft:mul", + "argument1": 4.0, + "argument2": { + "type": "minecraft:quarter_negative", + "argument": { + "type": "minecraft:mul", + "argument1": "minecraft:overworld/depth", + "argument2": { + "type": "minecraft:cache_2d", + "argument": "minecraft:overworld/factor" + } + } + } + } + }, + "max": 64.0, + "min": -30.0 + } + } + } + } + } + } + }, + "lava": 0.0, + "ridges": "minecraft:overworld/ridges", + "temperature": { + "type": "minecraft:shifted_noise", + "noise": "minecraft:temperature", + "shift_x": "minecraft:shift_x", + "shift_y": 0.0, + "shift_z": "minecraft:shift_z", + "xz_scale": 0.25, + "y_scale": 0.0 + }, + "vegetation": { + "type": "minecraft:shifted_noise", + "noise": "minecraft:vegetation", + "shift_x": "minecraft:shift_x", + "shift_y": 0.0, + "shift_z": "minecraft:shift_z", + "xz_scale": 0.0, + "y_scale": 0.0 + }, + "vein_gap": 0.0, + "vein_ridged": 0.0, + "vein_toggle": 0.0 + }, + "ore_veins_enabled": false, + "sea_level": 32, + "spawn_target": [ + { + "continentalness": [ + -0.11, + 1.0 + ], + "depth": 0.0, + "erosion": [ + -1.0, + 1.0 + ], + "humidity": [ + -1.0, + 1.0 + ], + "offset": 0.0, + "temperature": [ + -1.0, + 1.0 + ], + "weirdness": [ + -1.0, + -0.16 + ] + }, + { + "continentalness": [ + -0.11, + 1.0 + ], + "depth": 0.0, + "erosion": [ + -1.0, + 1.0 + ], + "humidity": [ + -1.0, + 1.0 + ], + "offset": 0.0, + "temperature": [ + -1.0, + 1.0 + ], + "weirdness": [ + 0.16, + 1.0 + ] + } + ], + "surface_rule": { + "type": "minecraft:sequence", + "sequence": [ + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:biome", + "biome_is": [ + "createnuclear:irradiated_plain" + ] + }, + "then_run": { + "type": "minecraft:sequence", + "sequence": [ + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:noise_threshold", + "max_threshold": 0.0465, + "min_threshold": 0.035, + "noise": "createnuclear:irradiated/erosion" + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:lead_ore" + } + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:noise_threshold", + "max_threshold": 0.0545, + "min_threshold": 0.039, + "noise": "createnuclear:irradiated/erosion" + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:lead_block" + } + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:noise_threshold", + "max_threshold": 0.069, + "min_threshold": 0.0545, + "noise": "createnuclear:irradiated/erosion" + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:raw_lead_block" + } + } + } + ] + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:vertical_gradient", + "false_at_and_above": { + "above_bottom": 5 + }, + "random_name": "minecraft:bedrock_floor", + "true_at_and_below": { + "above_bottom": 0 + } + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "minecraft:bedrock" + } + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:above_preliminary_surface" + }, + "then_run": { + "type": "minecraft:sequence", + "sequence": [ + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:stone_depth", + "add_surface_depth": false, + "offset": 0, + "secondary_depth_range": 0, + "surface_type": "floor" + }, + "then_run": { + "type": "minecraft:sequence", + "sequence": [ + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:biome", + "biome_is": [ + "createnuclear:irradiated_plain" + ] + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:raw_lead_block" + } + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:biome", + "biome_is": [] + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:lead_ore" + } + } + } + ] + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:stone_depth", + "add_surface_depth": true, + "offset": 0, + "secondary_depth_range": 0, + "surface_type": "floor" + }, + "then_run": { + "type": "minecraft:sequence", + "sequence": [ + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:biome", + "biome_is": [ + "createnuclear:irradiated_plain" + ] + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:raw_lead_block" + } + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:biome", + "biome_is": [] + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:steel_block" + } + } + } + ] + } + } + ] + } + }, + { + "type": "minecraft:condition", + "if_true": { + "type": "minecraft:vertical_gradient", + "false_at_and_above": { + "absolute": 4 + }, + "random_name": "minecraft:lunaslate", + "true_at_and_below": { + "absolute": -4 + } + }, + "then_run": { + "type": "minecraft:block", + "result_state": { + "Name": "createnuclear:enriched_soul_soil" + } + } + } + ] + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/content/effects/IrradiationCurseEffect.java b/src/main/java/net/nuclearteam/createnuclear/content/effects/IrradiationCurseEffect.java index 5f3d7042..895909a9 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/effects/IrradiationCurseEffect.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/effects/IrradiationCurseEffect.java @@ -26,7 +26,7 @@ public class IrradiationCurseEffect extends VicinityEffect { public IrradiationCurseEffect(MobEffectCategory category, int color) { super(category, color, amplifier -> 15, - e -> !e.getType().is(CNTags.CNEntityTags.IRRADIATED_IMMUNE.tag) && !e.hasEffect(CNEffects.RADIATION.get()), + (e) -> !e.getType().is(CNTags.CNEntityTags.IRRADIATED_IMMUNE.tag) && !e.hasEffect(CNEffects.RADIATION.get()), timer -> {}, () -> new MobEffectInstance(MobEffects.ABSORPTION, 300)); } diff --git a/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java b/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java index bc92be83..0b8de28d 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java @@ -4,9 +4,11 @@ import net.minecraft.world.effect.MobEffectCategory; import net.minecraft.world.effect.MobEffectInstance; import net.minecraft.world.entity.LivingEntity; +import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.nuclearteam.createnuclear.CNEffects; import net.nuclearteam.createnuclear.CNTags; +import net.nuclearteam.createnuclear.CreateNuclear; import net.nuclearteam.createnuclear.content.equipment.armor.AntiRadiationArmorItem; import net.minecraft.world.entity.ai.attributes.Attributes; import net.minecraft.world.entity.ai.attributes.AttributeModifier; @@ -20,13 +22,18 @@ public class RadiationEffect extends VicinityEffect { public RadiationEffect() { super(MobEffectCategory.HARMFUL, 15453236, amplifier -> 10, - e -> { + (e) -> { boolean isWearingAntiRadiationArmor = false; - for (ItemStack armor : e.getArmorSlots()) { - if (AntiRadiationArmorItem.Armor.isArmored(armor)) { - isWearingAntiRadiationArmor = true; - break; - } + + if (e instanceof Player player) { + isWearingAntiRadiationArmor = AntiRadiationArmorItem.Armor.isArmored(player.getArmorSlots()); +// for (ItemStack armor : e.getArmorSlots()) { +// CreateNuclear.LOGGER.warn("AntiRadiationArmorItem.Armor.isArmored(armor) {}", AntiRadiationArmorItem.Armor.isArmored(armor)); +// if (AntiRadiationArmorItem.Armor.isArmored(armor)) { +// isWearingAntiRadiationArmor = true; +// break; +// } +// } } return !e.getType().is(CNTags.CNEntityTags.IRRADIATED_IMMUNE.tag) diff --git a/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java b/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java index f3f8b3f5..1f7c61ca 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java @@ -5,15 +5,10 @@ import net.minecraft.world.effect.MobEffectInstance; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.LivingEntity; -import net.nuclearteam.createnuclear.CNBlocks; import net.nuclearteam.createnuclear.CreateNuclear; -import org.jetbrains.annotations.Nullable; import java.util.List; -import java.util.function.Consumer; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.function.UnaryOperator; +import java.util.function.*; public class VicinityEffect extends MobEffect { private final UnaryOperator areaSize; @@ -33,11 +28,17 @@ protected VicinityEffect(MobEffectCategory category, int color, UnaryOperator nearbyEntities = entity.level().getEntities(entity, entity.getBoundingBox().inflate(areaSize.apply(amplifier)), e -> e instanceof LivingEntity target && filter.test(target)); + List nearbyEntities = entity.level().getEntities(entity, entity.getBoundingBox().inflate(areaSize.apply(amplifier)), e -> e instanceof LivingEntity target && filter.test(target)); + + CreateNuclear.LOGGER.warn("Nearby Entities Count: {}, {}", nearbyEntities.size(), entity.getDisplayName().getString()); for (Entity nearbyEntity : nearbyEntities) { LivingEntity nearby = (LivingEntity) nearbyEntity; + if (nearby == entity) { + continue; + } + for (Supplier effect : effects) { if (cooldownTicks == 0) { nearby.addEffect(effect.get()); diff --git a/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java b/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java index 2d3a7f18..70b5f2ec 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java @@ -38,15 +38,15 @@ public class AntiRadiationArmorItem { public static class Helmet extends ArmorItem { protected final DyeColor color; - private final Multimap attributeModifiers; +// private final Multimap attributeModifiers; public Helmet(Properties properties, DyeColor color) { super(ARMOR_MATERIAL, HELMET, properties); this.color = color; - ImmutableMultimap.Builder builder = ImmutableMultimap.builder(); - UUID uuid = ARMOR_MODIFIER_UUID_PER_TYPE.get(HELMET); - builder.put(CNAttributes.IRRADIATED_RESISTANCE.get(), new AttributeModifier(uuid, "Armor Resistance Irradiation", 42, AttributeModifier.Operation.ADDITION)); - this.attributeModifiers = builder.build(); +// ImmutableMultimap.Builder builder = ImmutableMultimap.builder(); +// UUID uuid = ARMOR_MODIFIER_UUID_PER_TYPE.get(HELMET); +// builder.put(CNAttributes.IRRADIATED_RESISTANCE.get(), new AttributeModifier(uuid, "Armor Resistance Irradiation", 42, AttributeModifier.Operation.ADDITION)); +// this.attributeModifiers = builder.build(); } @Override @@ -107,10 +107,10 @@ public static TagKey getHelmetTag(String key) { : CNItemTags.ANTI_RADIATION_HELMET_DYE.tag; } - @Override - public Multimap getDefaultAttributeModifiers(EquipmentSlot pEquipmentSlot) { - return pEquipmentSlot == this.type.getSlot() ? this.attributeModifiers : super.getDefaultAttributeModifiers(pEquipmentSlot); - } +// @Override +// public Multimap getDefaultAttributeModifiers(EquipmentSlot pEquipmentSlot) { +// return pEquipmentSlot == this.type.getSlot() ? this.attributeModifiers : super.getDefaultAttributeModifiers(pEquipmentSlot); +// } } public static class Chestplate extends ArmorItem { @@ -322,9 +322,33 @@ public static ItemEntry getLeggingsByColor(DyeColor color) { } public static boolean isArmored(ItemStack item) { - return helmetMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) || - chestplateMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) || - leggingsMap.values().stream().anyMatch(entry -> entry.is(item.getItem())); + return helmetMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && + chestplateMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && + leggingsMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && + CNItems.ANTI_RADIATION_BOOTS.is(item.getItem()) + ; + } + + public static boolean isArmored(Iterable armorStacks) { + boolean hasHelmet = false; + boolean hasChestplate = false; + boolean hasLeggings = false; + boolean hasBoots = false; + + for (ItemStack itemStack : armorStacks) { + Item item = itemStack.getItem(); + if (CNItems.ANTI_RADIATION_HELMETS.contains(item)) { + hasHelmet = true; + } else if (CNItems.ANTI_RADIATION_CHESTPLATES.contains(item)) { + hasChestplate = true; + } else if (CNItems.ANTI_RADIATION_LEGGINGS.contains(item)) { + hasLeggings = true; + } else if (CNItems.ANTI_RADIATION_BOOTS.is(item)) { + hasBoots = true; + } + } + + return hasHelmet && hasChestplate && hasLeggings && hasBoots; } public static boolean isArmored2(ItemStack item) { diff --git a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java index cbdee861..bc0c269f 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java @@ -3,9 +3,12 @@ import com.simibubi.create.content.equipment.wrench.IWrenchable; import com.simibubi.create.foundation.block.IBE; import net.minecraft.MethodsReturnNonnullByDefault; -import net.minecraft.core.BlockPos; -import net.minecraft.core.Vec3i; +import net.minecraft.core.*; +import net.minecraft.core.registries.Registries; import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceKey; +import net.minecraft.server.level.ServerLevel; +import net.minecraft.util.Mth; import net.minecraft.util.StringRepresentable; import net.minecraft.world.InteractionHand; import net.minecraft.world.InteractionResult; @@ -13,20 +16,30 @@ import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.context.UseOnContext; import net.minecraft.world.level.Level; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.biome.BiomeResolver; +import net.minecraft.world.level.biome.Biomes; import net.minecraft.world.level.block.Block; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.entity.BlockEntityType; import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.chunk.ChunkStatus; +import net.minecraft.world.level.levelgen.structure.BoundingBox; +import net.minecraft.world.phys.Vec3; import net.nuclearteam.createnuclear.CNBlockEntityTypes; import net.nuclearteam.createnuclear.CNBlocks; +import net.nuclearteam.createnuclear.CreateNuclear; import net.nuclearteam.createnuclear.content.multiblock.controller.ReactorControllerBlock; import net.nuclearteam.createnuclear.content.multiblock.controller.ReactorControllerBlockEntity; import net.nuclearteam.createnuclear.content.multiblock.input.ReactorInput; import net.nuclearteam.createnuclear.foundation.utility.CreateNuclearLang; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNBiomes; import javax.annotation.Nullable; import javax.annotation.ParametersAreNonnullByDefault; +import java.util.ArrayList; import java.util.List; @ParametersAreNonnullByDefault @@ -34,6 +47,7 @@ @SuppressWarnings({"deprecation", "unused"}) public class ReactorCasing extends Block implements IWrenchable, IBE { private final TypeBlock typeBlock; + public boolean biomeUnchanged = true; public ReactorCasing(Properties properties, TypeBlock tBlock) { super(properties); @@ -44,6 +58,7 @@ public ReactorCasing(Properties properties, TypeBlock tBlock) { @Override // Called when the block is placed on the world public void onPlace(BlockState state, Level level, BlockPos pos, BlockState oldState, boolean movedByPiston) { super.onPlace(state, level, pos, oldState, movedByPiston); + changeBiome(CNBiomes.Irradiated.PLAIN, 12, new Vec3(5, 5, 5), (ServerLevel) level); List players = level.players(); FindController(pos, level, players, true); } @@ -97,6 +112,46 @@ public ReactorControllerBlock FindController(BlockPos blockPos, Level level, Lis return null; } + public static Vec3i floorAll(double x, double y, double z) { + return new Vec3i(Mth.floor(x), Mth.floor(y), Mth.floor(z)); + } + + public void changeBiome(ResourceKey biomeResourceKey, int pass, Vec3 effectCenter, ServerLevel serverLevel) { + CreateNuclear.LOGGER.info("ReactorBlock.changeBiome: {}", biomeUnchanged); + if(!biomeUnchanged) return; + double range = 300; + double passes = 13; + BoundingBox boundingbox = BoundingBox.fromCorners(floorAll(300 + (passes - 1) * 5.0 + effectCenter.x, 300 + (passes - 1) * 5.0 + effectCenter.y, range + (passes - 1) * 5.0 + effectCenter.z), floorAll(effectCenter.x - range + (passes - 1) * 5.0, effectCenter.y - range + (passes - 1) * 5.0, effectCenter.z - range + (passes - 1) * 5.0)); + ArrayList chunks = new ArrayList<>(); + CreateNuclear.LOGGER.info("ReactorBlock.change: {}", boundingbox); + for (int k = SectionPos.blockToSectionCoord(boundingbox.minZ()); k <= SectionPos.blockToSectionCoord(boundingbox.maxZ()); ++k) { + CreateNuclear.LOGGER.warn("ReactorBlock.for (int k =: {}", k); + for (int l = SectionPos.blockToSectionCoord(boundingbox.minX()); l <= SectionPos.blockToSectionCoord(boundingbox.maxX()); ++l) { + CreateNuclear.LOGGER.warn("ReactorBlock.int l =: {}, serverLevel.getChunk; {}", l, serverLevel.getChunk(l, k, ChunkStatus.FULL, false)); + ChunkAccess chunkAccess = serverLevel.getChunk(l, k, ChunkStatus.FULL, false); + if (chunkAccess != null) + chunks.add(chunkAccess); + } + } + + for (ChunkAccess chunkAccess : chunks) { + CreateNuclear.LOGGER.warn("test change biome chunk: {}", chunkAccess.getPos()); + Registry biomeRegistry = serverLevel.registryAccess().registryOrThrow(Registries.BIOME); + Biome biome = biomeRegistry.get(biomeResourceKey); + assert biome != null; + chunkAccess.fillBiomesFromNoise(makeResolver(biomeRegistry.wrapAsHolder(biome)), serverLevel.getChunkSource().randomState().sampler()); + chunkAccess.setUnsaved(true); + } + + serverLevel.getChunkSource().chunkMap.resendBiomesForChunks(chunks); + biomeUnchanged = false; + + } + + public static BiomeResolver makeResolver(Holder biomeHolder) { + return (x, y, z, climateSampler) -> biomeHolder; + } + @Override public Class getBlockEntityClass() { return ReactorCasingEntity.class; diff --git a/src/main/java/net/nuclearteam/createnuclear/foundation/events/CommentEvents.java b/src/main/java/net/nuclearteam/createnuclear/foundation/events/CommentEvents.java index ca843bc0..38730852 100644 --- a/src/main/java/net/nuclearteam/createnuclear/foundation/events/CommentEvents.java +++ b/src/main/java/net/nuclearteam/createnuclear/foundation/events/CommentEvents.java @@ -1,5 +1,6 @@ package net.nuclearteam.createnuclear.foundation.events; +import net.minecraft.core.Holder; import net.minecraft.server.level.ServerLevel; import net.minecraft.sounds.SoundEvents; import net.minecraft.util.TimeUtil; @@ -12,15 +13,19 @@ import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; +import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.block.LevelEvent; import net.minecraftforge.event.ForgeEventFactory; +import net.minecraftforge.event.TickEvent; import net.minecraftforge.event.TickEvent.Phase; import net.minecraftforge.event.TickEvent.ServerTickEvent; import net.minecraftforge.event.entity.EntityJoinLevelEvent; import net.minecraftforge.event.entity.living.*; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.event.entity.player.PlayerInteractEvent; +import net.minecraftforge.eventbus.api.Event; import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.LogicalSide; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; import net.nuclearteam.createnuclear.CNEffects; @@ -29,6 +34,8 @@ import net.nuclearteam.createnuclear.CNTags; import net.nuclearteam.createnuclear.content.contraptions.irradiated.IrradiatedAnimal; import net.nuclearteam.createnuclear.content.contraptions.irradiated.chicken.IrradiatedChicken; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNBiomes; +import org.spongepowered.asm.mixin.MixinEnvironment; @Mod.EventBusSubscriber public class CommentEvents { @@ -49,6 +56,23 @@ public static void onEntityJoinWorld(EntityJoinLevelEvent event) { } } + @SubscribeEvent + public static void onServerWorldTick(LivingEvent.LivingTickEvent event) { + LivingEntity entityLiving = event.getEntity(); + Level world = entityLiving.level(); + if (world == null) + return; + + if (world.isClientSide) + return; + if (entityLiving.tickCount % 20 == 0) return; + if (entityLiving instanceof Player p && p.isSpectator()) return; + Holder biome = world.getBiome(entityLiving.getOnPos()); + if (biome.is(CNBiomes.Irradiated.PLAIN)){ + entityLiving.addEffect(new MobEffectInstance(CNEffects.RADIATION.get(),600,0, false, true, true)); + } + } + @SubscribeEvent public static void onEntityInteract(PlayerInteractEvent.EntityInteract event) { Entity entity = event.getTarget(); diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/data/GeneratedEntriesProvider.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/data/GeneratedEntriesProvider.java index e13ab777..2da7db37 100644 --- a/src/main/java/net/nuclearteam/createnuclear/infrastructure/data/GeneratedEntriesProvider.java +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/data/GeneratedEntriesProvider.java @@ -12,6 +12,10 @@ import net.nuclearteam.createnuclear.infrastructure.worldgen.CNBiomeModifiers; import net.nuclearteam.createnuclear.infrastructure.worldgen.CNConfiguredFeatures; import net.nuclearteam.createnuclear.infrastructure.worldgen.CNPlacedFeatures; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNBiomes; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNDensityFunctions; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNNoiseData; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNNoiseGeneratorSettings; import java.util.Set; import java.util.concurrent.CompletableFuture; @@ -23,6 +27,10 @@ public class GeneratedEntriesProvider extends DatapackBuiltinEntriesProvider { .add(Registries.CONFIGURED_FEATURE, (RegistryBootstrap) CNConfiguredFeatures::bootstrap) .add(Registries.PLACED_FEATURE, CNPlacedFeatures::bootstrap) .add(ForgeRegistries.Keys.BIOME_MODIFIERS, CNBiomeModifiers::bootstrap) + .add(Registries.BIOME, CNBiomes::bootstrapRegistries) + .add(Registries.DENSITY_FUNCTION, CNDensityFunctions::bootstrapRegistries) + .add(Registries.NOISE_SETTINGS, CNNoiseGeneratorSettings::bootstrapRegistries) + .add(Registries.NOISE, CNNoiseData::bootstrapRegistries) ; public GeneratedEntriesProvider(PackOutput output, CompletableFuture registries) { diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java new file mode 100644 index 00000000..390fe6fc --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java @@ -0,0 +1,55 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; + +import net.minecraft.core.HolderGetter; +import net.minecraft.core.particles.ParticleTypes; +import net.minecraft.core.registries.Registries; +import net.minecraft.data.worldgen.BootstapContext; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.level.biome.*; +import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; +import net.minecraft.world.level.levelgen.placement.PlacedFeature; +import net.nuclearteam.createnuclear.CreateNuclear; +import org.jetbrains.annotations.NotNull; + +public class CNBiomes { + public static final class Irradiated { + public static final ResourceKey PLAIN = key("irradiated_plain"); + } + + public static final ResourceKey IRRADIATED_PLAIN = ResourceKey.create(Registries.BIOME, new ResourceLocation("irradiated_plain")); + + public static Biome irradiatedPlain(HolderGetter holderGetter, HolderGetter> holder2) { + Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); + MobSpawnSettings.Builder spawn = new MobSpawnSettings.Builder(); + BiomeGenerationSettings.Builder genSettings = new BiomeGenerationSettings.Builder(holderGetter, holder2); + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); + effects + .fogColor(0) + .ambientParticle(new AmbientParticleSettings(ParticleTypes.CRIMSON_SPORE, 0.025F)) + .waterColor(4159204) + .waterFogColor(329011) + .skyColor(0) + ; + return builder + .downfall(0) + .temperature(1) + .specialEffects(effects.build()) + .mobSpawnSettings(spawn.build()) + .hasPrecipitation(false) + .generationSettings(genSettings.build()) + .temperatureAdjustment(Biome.TemperatureModifier.NONE).build(); + } + + public static void bootstrapRegistries(BootstapContext context) { + HolderGetter featureLookup = context.lookup(Registries.PLACED_FEATURE); + HolderGetter> carverLookup = context.lookup(Registries.CONFIGURED_CARVER); + + context.register(IRRADIATED_PLAIN, irradiatedPlain(context.lookup(Registries.PLACED_FEATURE), context.lookup(Registries.CONFIGURED_CARVER))); + context.register(Irradiated.PLAIN, IrradiatedBiomes.createPlain(featureLookup, carverLookup)); + } + + public static @NotNull ResourceKey key(String id) { + return ResourceKey.create(Registries.BIOME, CreateNuclear.asResource(id)); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNDensityFunctions.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNDensityFunctions.java new file mode 100644 index 00000000..1528bd14 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNDensityFunctions.java @@ -0,0 +1,50 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; + +import net.minecraft.core.HolderGetter; +import net.minecraft.core.registries.Registries; +import net.minecraft.data.worldgen.BootstapContext; +import net.minecraft.resources.ResourceKey; +import net.minecraft.world.level.levelgen.DensityFunction; +import net.minecraft.world.level.levelgen.DensityFunctions; +import net.minecraft.world.level.levelgen.NoiseRouterData; +import net.minecraft.world.level.levelgen.synth.BlendedNoise; +import net.nuclearteam.createnuclear.CreateNuclear; + +public class CNDensityFunctions { + public static final ResourceKey NOODLES = createKey("caves/noodles"); + + public static final class Irradiated { + public static final ResourceKey EROSION = createKey("irradiated/erosion"); + public static final ResourceKey FINAL_DENSITY = createKey("irradiated/final_density"); + } + + private static ResourceKey createKey(String id) { + return ResourceKey.create(Registries.DENSITY_FUNCTION, CreateNuclear.asResource(id)); + } + + public static void bootstrapRegistries(BootstapContext context) { + var vanillaRegistry = context.lookup(Registries.DENSITY_FUNCTION); + var noiseRegistry = context.lookup(Registries.NOISE); +// DensityFunction shiftX = getFunction(vanillaRegistry, NoiseRouterData.SHIFT_X); +// DensityFunction shiftZ = getFunction(vanillaRegistry, NoiseRouterData.SHIFT_Z); +// DensityFunction y = getFunction(vanillaRegistry, NoiseRouterData.Y); + + context.register(Irradiated.EROSION, DensityFunctions.add( + DensityFunctions.yClampedGradient(0, 90, 1, -1), + BlendedNoise.createUnseeded(0.25, 0.375, 80.0, 160.0, 8.0) + )); + + context.register(Irradiated.FINAL_DENSITY, DensityFunctions.add( + DensityFunctions.yClampedGradient(0, 90, 1, -1), + BlendedNoise.createUnseeded(0.25, 0.375, 80.0, 160.0, 8.0) + )); + } + + private static DensityFunction registerAndWrap(BootstapContext context, ResourceKey key, DensityFunction densityFunction) { + return new DensityFunctions.HolderHolder(context.register(key, densityFunction)); + } + + public static DensityFunction getFunction(HolderGetter densityFunctions, ResourceKey key) { + return new DensityFunctions.HolderHolder(densityFunctions.getOrThrow(key)); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseData.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseData.java new file mode 100644 index 00000000..a5245463 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseData.java @@ -0,0 +1,33 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; + +import net.minecraft.core.registries.Registries; +import net.minecraft.data.worldgen.BootstapContext; +import net.minecraft.resources.ResourceKey; +import net.minecraft.world.level.levelgen.synth.NormalNoise.NoiseParameters; +import net.nuclearteam.createnuclear.CreateNuclear; + +public class CNNoiseData { + public static final ResourceKey EROSION = createKey("irradiated/erosion"); + public static final ResourceKey BASALT_MARE = createKey("irradiated/basalt_mare"); + public static final ResourceKey BASALT_MARE_HEIGHT = createKey("irradiated/basalt_mare_height"); + + private static ResourceKey createKey(String id) { + return ResourceKey.create(Registries.NOISE, CreateNuclear.asResource(id)); + } + + public static void bootstrapRegistries(BootstapContext context) { +// register(context, EROSION, -11, 1, 1, 0, 1, 1); +// register(context, BASALT_MARE, 5, 0, 0.1, 0.2, 0.1, 0, 0, 0, 0); +// register(context, BASALT_MARE_HEIGHT, -12, 0.3); + } + + private static void register( + BootstapContext context, + ResourceKey key, + int firstOctave, + double amplitude, + double... otherAmplitudes + ) { + context.register(key, new NoiseParameters(firstOctave, amplitude, otherAmplitudes)); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseGeneratorSettings.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseGeneratorSettings.java new file mode 100644 index 00000000..52e6d466 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNNoiseGeneratorSettings.java @@ -0,0 +1,100 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; + +import net.minecraft.core.HolderGetter; +import net.minecraft.core.registries.Registries; +import net.minecraft.data.worldgen.BootstapContext; +import net.minecraft.resources.ResourceKey; +import net.minecraft.world.level.biome.OverworldBiomeBuilder; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.levelgen.*; +import net.minecraft.world.level.levelgen.synth.NormalNoise; +import net.nuclearteam.createnuclear.CNBlocks; +import net.nuclearteam.createnuclear.CreateNuclear; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.surfacerule.IrradiatedSurfaceRules; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.surfacerule.IrradiatedSurfaceRules2; +import org.jetbrains.annotations.NotNull; + +public class CNNoiseGeneratorSettings { + public static final ResourceKey IRRADIATED = key("irradiated_noise"); + + public static void bootstrapRegistries(BootstapContext context) { + HolderGetter densityLookup = context.lookup(Registries.DENSITY_FUNCTION); + HolderGetter noiseLookup = context.lookup(Registries.NOISE); + + context.register(IRRADIATED, new NoiseGeneratorSettings( + NoiseSettings.create(-32, 256, 1, 2), + CNBlocks.STEEL_BLOCK.get().defaultBlockState(), + Blocks.AIR.defaultBlockState(), + CNNoiseGeneratorSettings.irradiated(densityLookup, noiseLookup), + IrradiatedSurfaceRules2.DEFAULT_RULE, + new OverworldBiomeBuilder().spawnTarget(), + 32, + false, + false, + false, + false + )); + } + + public static NoiseRouter irradiated(HolderGetter densityLookup, HolderGetter noiseLookup) { + DensityFunction shiftX = CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.SHIFT_X); + DensityFunction shiftZ = CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.SHIFT_Z); + DensityFunction y = CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.Y); + return new NoiseRouter( + DensityFunctions.constant(1), // barrierNoise + DensityFunctions.zero(), // fluidLevelFloodednessNoise + DensityFunctions.zero(), // fluidLevelSpreadNoise + DensityFunctions.zero(), // lavaNoise + DensityFunctions.shiftedNoise2d( + shiftX, shiftZ, 0.25, noiseLookup.getOrThrow(Noises.TEMPERATURE) + ), // temperature + DensityFunctions.shiftedNoise2d( + shiftX, shiftZ, 0, noiseLookup.getOrThrow(Noises.VEGETATION) + ), // vegetation + CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.CONTINENTS), // continents + CNDensityFunctions.getFunction(densityLookup, CNDensityFunctions.Irradiated.EROSION), // erosion + CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.DEPTH), // depth + CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.RIDGES), // ridges + DensityFunctions.add( + DensityFunctions.constant(0.1171875), + DensityFunctions.mul( + DensityFunctions.yClampedGradient( + -30, -40, 0, 1 + ), + DensityFunctions.add( + DensityFunctions.constant(-0.1171875), + DensityFunctions.add( + DensityFunctions.constant(-0.078125), + DensityFunctions.mul( + DensityFunctions.yClampedGradient( + 240, 256, 1, 0 + ), + DensityFunctions.add( + DensityFunctions.constant(0.078125), + DensityFunctions.add( + DensityFunctions.constant(-0.703125), + DensityFunctions.mul( + DensityFunctions.constant(4), + DensityFunctions.mul( + CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.DEPTH), + DensityFunctions.cache2d(CNDensityFunctions.getFunction(densityLookup, NoiseRouterData.FACTOR)) + ).quarterNegative() + ) + ).clamp(-30, 64) + ) + ) + ) + ) + ) + ), // initialDensityWithoutJaggedness + DensityFunctions.blendDensity(CNDensityFunctions.getFunction(densityLookup, CNDensityFunctions.Irradiated.FINAL_DENSITY)), // finalDensity + DensityFunctions.zero(), // veinToggle + DensityFunctions.zero(), // veinRidged + DensityFunctions.zero() // veinGap + ); + } + + private static @NotNull ResourceKey key(String id) { + return ResourceKey.create(Registries.NOISE_SETTINGS, CreateNuclear.asResource(id)); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java new file mode 100644 index 00000000..4c5cfa69 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java @@ -0,0 +1,57 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; + +import net.minecraft.core.HolderGetter; +import net.minecraft.data.worldgen.Carvers; +import net.minecraft.data.worldgen.placement.MiscOverworldPlacements; +import net.minecraft.world.entity.MobCategory; +import net.minecraft.world.level.biome.*; +import net.minecraft.world.level.levelgen.GenerationStep; +import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; +import net.minecraft.world.level.levelgen.placement.PlacedFeature; +import net.nuclearteam.createnuclear.CNEntityType; + +public class IrradiatedBiomes { + public static Biome createPlain(HolderGetter featureLookup, HolderGetter> carverLookup) { + return IrradiatedBiomes.irradiated(featureLookup, carverLookup, new BiomeGenerationSettings.Builder(featureLookup, carverLookup)); + } + + public static void monsters(MobSpawnSettings.Builder builder, int zombieWeight, int zombieVillagerWeight, int skeletonWeight) { +// builder.addSpawn(MobCategory.MONSTER, new MobSpawnSettings.SpawnerData(CNEntityType.IRRADIATED_CAT.get(), 100, 2, 4)); +// builder.addSpawn(MobCategory.MONSTER, new MobSpawnSettings.SpawnerData(CNEntityType.IRRADIATED_CHICKEN.get(), 100, 1, 4)); +// builder.addSpawn(MobCategory.MONSTER, new MobSpawnSettings.SpawnerData(CNEntityType.IRRADIATED_WOLF.get(), 100, 2, 4)); + } + + public static void addDefaultIrradiatedOres(BiomeGenerationSettings.Builder builder) { + builder.addFeature(GenerationStep.Decoration.UNDERGROUND_STRUCTURES, MiscOverworldPlacements.BLUE_ICE); + builder.addCarver(GenerationStep.Carving.AIR, Carvers.NETHER_CAVE); + } + + public static void addDefaultSoftDisks(BiomeGenerationSettings.Builder builder) { + // builder.addFeature(GenerationStep.Decoration.UNDERGROUND_ORES, GCOrePlacedFeatures.BASALT_DISK_MOON); + builder.addFeature(GenerationStep.Decoration.SURFACE_STRUCTURES, MiscOverworldPlacements.VOID_START_PLATFORM); + } + public static Biome irradiated(HolderGetter featureGetter, HolderGetter> carverGetter, BiomeGenerationSettings.Builder generation) { + MobSpawnSettings.Builder spawnBuilder = new MobSpawnSettings.Builder(); + BiomeSpecialEffects.Builder effectBuilder = new BiomeSpecialEffects.Builder(); + effectBuilder.waterColor(4159204) + .waterFogColor(329011) + .fogColor(329011) + .skyColor(0) + .ambientMoodSound(AmbientMoodSettings.LEGACY_CAVE_SETTINGS) + ; + + IrradiatedBiomes.addDefaultIrradiatedOres(generation); + IrradiatedBiomes.addDefaultSoftDisks(generation); + IrradiatedBiomes.monsters(spawnBuilder, 95,5,100); +// generation.addCarver(GenerationStep.Carving.AIR, ) + + return new Biome.BiomeBuilder() + .mobSpawnSettings(spawnBuilder.build()) + .hasPrecipitation(false) + .temperature(2f) + .downfall(0f) + .specialEffects(effectBuilder.build()) + .generationSettings(generation.build()) + .build(); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/BiomeTagRule.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/BiomeTagRule.java new file mode 100644 index 00000000..25ba3b0a --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/BiomeTagRule.java @@ -0,0 +1,35 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome.surfacerule; + +import com.mojang.serialization.MapCodec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.core.registries.Registries; +import net.minecraft.tags.TagKey; +import net.minecraft.util.KeyDispatchDataCodec; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.levelgen.SurfaceRules; +import org.jetbrains.annotations.NotNull; + +public record BiomeTagRule(@NotNull TagKey tag) implements SurfaceRules.ConditionSource { + private static final MapCodec CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(TagKey.codec(Registries.BIOME).fieldOf("tag").forGetter(rule -> rule.tag)).apply(instance, BiomeTagRule::new)); + + @Override + public KeyDispatchDataCodec codec() { + return KeyDispatchDataCodec.of(BiomeTagRule.CODEC); + } + + @Override + public SurfaceRules.Condition apply(SurfaceRules.Context context) { + return null; + } + + private class Predicate extends SurfaceRules.LazyYCondition { + protected Predicate(SurfaceRules.Context context) { + super(context); + } + + @Override + protected boolean compute() { + return this.context.biome.get().is(BiomeTagRule.this.tag); + } + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules.java new file mode 100644 index 00000000..19a78bfb --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules.java @@ -0,0 +1,30 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome.surfacerule; + +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.levelgen.SurfaceRules; +import net.minecraft.world.level.levelgen.VerticalAnchor; +import net.nuclearteam.createnuclear.CNBlocks; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNBiomes; +import org.jetbrains.annotations.NotNull; + +public class IrradiatedSurfaceRules { + private static final SurfaceRules.RuleSource BEDROCK = block(Blocks.BEDROCK); + public static final SurfaceRules.RuleSource HARD_ROCK = block(CNBlocks.ENRICHED_SOUL_SOIL.get()); + + public static final SurfaceRules.RuleSource IRRADIATED = createDefaultRule(); + + public static @NotNull SurfaceRules.RuleSource createDefaultRule() { + return SurfaceRules.sequence( + SurfaceRules.ifTrue( + SurfaceRules.isBiome(CNBiomes.Irradiated.PLAIN), + HARD_ROCK + ), + SurfaceRules.ifTrue(SurfaceRules.verticalGradient("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5)), BEDROCK) + ); + } + + private static @NotNull SurfaceRules.RuleSource block(@NotNull Block block) { + return SurfaceRules.state(block.defaultBlockState()); + } +} \ No newline at end of file diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules2.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules2.java new file mode 100644 index 00000000..5f832072 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/surfacerule/IrradiatedSurfaceRules2.java @@ -0,0 +1,91 @@ +package net.nuclearteam.createnuclear.infrastructure.worldgen.biome.surfacerule; + +import com.mojang.serialization.Codec; +import com.mojang.serialization.MapCodec; +import net.minecraft.core.Registry; +import net.minecraft.core.registries.BuiltInRegistries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.tags.TagKey; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.levelgen.SurfaceRules; +import net.minecraft.world.level.levelgen.SurfaceRules.RuleSource; +import net.minecraft.world.level.levelgen.SurfaceRules.ConditionSource; +import net.minecraft.world.level.levelgen.VerticalAnchor; +import net.nuclearteam.createnuclear.CNBlocks; +import net.nuclearteam.createnuclear.CreateNuclear; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNBiomes; +import net.nuclearteam.createnuclear.infrastructure.worldgen.biome.CNNoiseData; +import org.jetbrains.annotations.NotNull; + +public class IrradiatedSurfaceRules2 { + private static final ConditionSource IS_MARE = biome(CNBiomes.Irradiated.PLAIN); + private static final ConditionSource IS_HIGHLANDS = biome(); + + private static final RuleSource BEDROCK = block(Blocks.BEDROCK); + private static final RuleSource LUNASLATE = block(CNBlocks.ENRICHED_SOUL_SOIL.get()); + private static final RuleSource MOON_DIRT = block(CNBlocks.STEEL_BLOCK.get()); + private static final RuleSource MOON_ROCK = block(CNBlocks.LEAD_BLOCK.get()); + private static final RuleSource MOON_TURF = block(CNBlocks.LEAD_ORE.get()); + private static final RuleSource MOON_BASALT = block(CNBlocks.RAW_LEAD_BLOCK.get()); + private static final RuleSource DEBUG_STATE = block(CNBlocks.REACTOR_CASING.get()); + + private static final RuleSource SECONDARY_MATERIAL = SurfaceRules.sequence( + SurfaceRules.ifTrue(IS_MARE, MOON_BASALT), + SurfaceRules.ifTrue(IS_HIGHLANDS, MOON_DIRT) + ); + private static final RuleSource SURFACE_MATERIAL = SurfaceRules.sequence( + SurfaceRules.ifTrue(IS_MARE, MOON_BASALT), + SurfaceRules.ifTrue(IS_HIGHLANDS, MOON_TURF) + ); + private static final RuleSource SURFACE_GENERATION = SurfaceRules.sequence( + SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SURFACE_MATERIAL), + SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SECONDARY_MATERIAL) + ); + + public static final RuleSource DEFAULT_RULE = createDefaultRule(); + + public static @NotNull RuleSource createDefaultRule() { + return SurfaceRules.sequence( + SurfaceRules.ifTrue( + SurfaceRules.isBiome(CNBiomes.Irradiated.PLAIN), + SurfaceRules.sequence( + SurfaceRules.ifTrue( + SurfaceRules.noiseCondition(CNNoiseData.EROSION, 0.035, 0.0465), + MOON_TURF + ), + SurfaceRules.ifTrue( + SurfaceRules.noiseCondition(CNNoiseData.EROSION, 0.039, 0.0545), + MOON_ROCK + ), + SurfaceRules.ifTrue( + SurfaceRules.noiseCondition(CNNoiseData.EROSION, 0.0545, 0.069), + MOON_BASALT + ) + ) + ), + + SurfaceRules.ifTrue(SurfaceRules.verticalGradient("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5)), BEDROCK), + SurfaceRules.ifTrue(SurfaceRules.abovePreliminarySurface(), SURFACE_GENERATION), + SurfaceRules.ifTrue(SurfaceRules.verticalGradient("lunaslate", VerticalAnchor.absolute(-4), VerticalAnchor.absolute(4)), LUNASLATE) + ); + } + + private static @NotNull RuleSource block(@NotNull Block block) { + return SurfaceRules.state(block.defaultBlockState()); + } + + public static SurfaceRules.@NotNull ConditionSource biome(@NotNull TagKey biome) { + return new BiomeTagRule(biome); + } + + @SafeVarargs + public static SurfaceRules.@NotNull ConditionSource biome(@NotNull ResourceKey @NotNull ... keys) { + return SurfaceRules.isBiome(keys); + } + + public static void register() { + Registry.register(BuiltInRegistries.MATERIAL_RULE, CreateNuclear.asResource("irradiated_surface"), Codec.unit(DEFAULT_RULE)); + } +} \ No newline at end of file diff --git a/src/main/resources/META-INF/accesstransformer.cfg b/src/main/resources/META-INF/accesstransformer.cfg index 79226f6f..8d9a24bb 100644 --- a/src/main/resources/META-INF/accesstransformer.cfg +++ b/src/main/resources/META-INF/accesstransformer.cfg @@ -1,3 +1,11 @@ public net.minecraft.world.item.crafting.RecipeManager f_44007_ # recipes public net.minecraft.world.item.alchemy.PotionBrewing m_43513_(Lnet/minecraft/world/item/alchemy/Potion;Lnet/minecraft/world/item/Item;Lnet/minecraft/world/item/alchemy/Potion;)V + +public net.minecraft.world.level.levelgen.SurfaceRules$Context +public net.minecraft.world.level.levelgen.SurfaceRules$LazyYCondition +public net.minecraft.world.level.levelgen.SurfaceRules$Condition +public net.minecraft.world.level.levelgen.SurfaceRules$Context f_189555_ # biome +public net.minecraft.world.level.levelgen.NoiseRouterData f_209448_ # SHIFT_X +public net.minecraft.world.level.levelgen.NoiseRouterData f_209447_ # Y +public net.minecraft.world.level.levelgen.NoiseRouterData f_209449_ # SHIFT_Z \ No newline at end of file diff --git a/src/main/resources/createnuclear.forge.mixins.json b/src/main/resources/createnuclear.forge.mixins.json index 1a26dd56..10717a86 100644 --- a/src/main/resources/createnuclear.forge.mixins.json +++ b/src/main/resources/createnuclear.forge.mixins.json @@ -6,6 +6,7 @@ "mixins": [ "BaseFireBlockMixin" ], + "accessWidener": "createnuclear.accesswidener", "client": [ ], "injectors": { From a8aa34846efaab7f932fa9dfb0dd60c9ea3df0a6 Mon Sep 17 00:00:00 2001 From: Giovanni Date: Sun, 23 Nov 2025 16:29:23 +0100 Subject: [PATCH 2/9] Refactor radiation effect logic to utilize full armor set checks and improve cooldown management in vicinity effects --- .../content/effects/RadiationEffect.java | 15 +++--- .../content/effects/VicinityEffect.java | 46 +++++++++++++------ .../armor/AntiRadiationArmorItem.java | 35 +++++++++----- 3 files changed, 64 insertions(+), 32 deletions(-) diff --git a/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java b/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java index 0b8de28d..ddcff2b8 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/effects/RadiationEffect.java @@ -23,18 +23,15 @@ public RadiationEffect() { super(MobEffectCategory.HARMFUL, 15453236, amplifier -> 10, (e) -> { - boolean isWearingAntiRadiationArmor = false; - if (e instanceof Player player) { - isWearingAntiRadiationArmor = AntiRadiationArmorItem.Armor.isArmored(player.getArmorSlots()); + boolean isWearingAntiRadiationArmor = AntiRadiationArmorItem.Armor.isFullSet(e.getArmorSlots()); // for (ItemStack armor : e.getArmorSlots()) { -// CreateNuclear.LOGGER.warn("AntiRadiationArmorItem.Armor.isArmored(armor) {}", AntiRadiationArmorItem.Armor.isArmored(armor)); -// if (AntiRadiationArmorItem.Armor.isArmored(armor)) { +// CreateNuclear.LOGGER.warn("AntiRadiationArmorItem.Armor.isFullSet(armor) {}", AntiRadiationArmorItem.Armor.isFullSet(armor)); +// if (AntiRadiationArmorItem.Armor.isFullSet(armor)) { // isWearingAntiRadiationArmor = true; // break; // } // } - } return !e.getType().is(CNTags.CNEntityTags.IRRADIATED_IMMUNE.tag) && !e.hasEffect(CNEffects.RADIATION.get()) @@ -74,6 +71,12 @@ public boolean isDurationEffectTick(int duration, int amplifier) { public void applyEffectTick(LivingEntity entity, int amplifier) { super.applyEffectTick(entity, amplifier); + // Do not apply damage if the entity is wearing anti-radiation armor + boolean wearingAntiRad = AntiRadiationArmorItem.Armor.isFullSet(entity.getArmorSlots()); + if (wearingAntiRad) { + return; + } + // Apply radiation damage (magic type), scaled by amplifier int damage = 1 << amplifier; entity.hurt(entity.damageSources().magic(), damage); diff --git a/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java b/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java index 1f7c61ca..179f918b 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/effects/VicinityEffect.java @@ -4,10 +4,14 @@ import net.minecraft.world.effect.MobEffectCategory; import net.minecraft.world.effect.MobEffectInstance; import net.minecraft.world.entity.Entity; +import net.minecraft.server.level.ServerLevel; import net.minecraft.world.entity.LivingEntity; import net.nuclearteam.createnuclear.CreateNuclear; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.UUID; import java.util.function.*; public class VicinityEffect extends MobEffect { @@ -15,7 +19,7 @@ public class VicinityEffect extends MobEffect { private final Predicate filter; private final Supplier[] effects; - private int cooldownTicks = 500; + private final Map cooldowns = new HashMap<>(); @SafeVarargs protected VicinityEffect(MobEffectCategory category, int color, UnaryOperator areaSize, Predicate filter, Consumer timer, Supplier... effects) { @@ -30,25 +34,39 @@ protected VicinityEffect(MobEffectCategory category, int color, UnaryOperator nearbyEntities = entity.level().getEntities(entity, entity.getBoundingBox().inflate(areaSize.apply(amplifier)), e -> e instanceof LivingEntity target && filter.test(target)); - - CreateNuclear.LOGGER.warn("Nearby Entities Count: {}, {}", nearbyEntities.size(), entity.getDisplayName().getString()); for (Entity nearbyEntity : nearbyEntities) { LivingEntity nearby = (LivingEntity) nearbyEntity; - if (nearby == entity) { - continue; - } - - for (Supplier effect : effects) { - if (cooldownTicks == 0) { - nearby.addEffect(effect.get()); - cooldownTicks = 500; - } else { - cooldownTicks--; - CreateNuclear.LOGGER.warn("Test Duree: {}, entity: {}", cooldownTicks, nearby.getUUID()); + int couldown = getCooldown(nearby); + if (couldown <= 0) { + for (Supplier effect : effects) { + nearby.addEffect(effect.get()); } + + setCooldown(nearby, 500); + + } else { + setCooldown(nearby, couldown - 1); + CreateNuclear.LOGGER.warn("Test Duree: {}, entity: {}", couldown, nearby.getUUID()); } } + + + // Clean up cooldowns only on the server: remove entries whose entity is gone or marked removed. + if (entity.level() instanceof ServerLevel serverLevel) { + cooldowns.entrySet().removeIf(entry -> { + Entity e = serverLevel.getEntity(entry.getKey()); + return e == null || e.isRemoved(); + }); + } + } + + private int getCooldown(LivingEntity entity) { + return cooldowns.getOrDefault(entity.getUUID(), 0); + } + + private void setCooldown(LivingEntity entity, int ticks) { + cooldowns.put(entity.getUUID(), ticks); } @Override diff --git a/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java b/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java index 70b5f2ec..ee7316f4 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/equipment/armor/AntiRadiationArmorItem.java @@ -8,6 +8,7 @@ import net.minecraft.tags.TagKey; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.EquipmentSlot; +import net.minecraft.world.entity.LivingEntity; import net.minecraft.world.entity.ai.attributes.Attribute; import net.minecraft.world.entity.ai.attributes.AttributeModifier; import net.minecraft.world.item.*; @@ -321,15 +322,21 @@ public static ItemEntry getLeggingsByColor(DyeColor color) { return leggingsMap.get(color); } - public static boolean isArmored(ItemStack item) { - return helmetMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && - chestplateMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && - leggingsMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) && - CNItems.ANTI_RADIATION_BOOTS.is(item.getItem()) - ; + /** + * Returns true if the given ItemStack corresponds to any piece of the anti-radiation armor. + */ + public static boolean isAnyPiece(ItemStack item) { + return helmetMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) + || chestplateMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) + || leggingsMap.values().stream().anyMatch(entry -> entry.is(item.getItem())) + || CNItems.ANTI_RADIATION_BOOTS.is(item.getItem()); } - public static boolean isArmored(Iterable armorStacks) { + /** + * Returns true when the provided armor stacks contain a full anti-radiation set + * (helmet, chestplate, leggings and boots). + */ + public static boolean isFullSet(Iterable armorStacks) { boolean hasHelmet = false; boolean hasChestplate = false; boolean hasLeggings = false; @@ -351,12 +358,16 @@ public static boolean isArmored(Iterable armorStacks) { return hasHelmet && hasChestplate && hasLeggings && hasBoots; } + /** + * Returns true when the given entity is fully wearing the anti-radiation set. + */ + public static boolean isFullSet(LivingEntity entity) { + return isFullSet(entity.getArmorSlots()); + } + + /** Alias for {@link #isAnyPiece(ItemStack)} kept for compatibility. */ public static boolean isArmored2(ItemStack item) { - return CNItems.ANTI_RADIATION_HELMETS.contains(item.getItem()) - || CNItems.ANTI_RADIATION_CHESTPLATES.contains(item.getItem()) - || CNItems.ANTI_RADIATION_LEGGINGS.contains(item.getItem()) - || CNItems.ANTI_RADIATION_BOOTS.is(item.getItem()) - ; + return isAnyPiece(item); } } From bb53cc8a4f1cf431fb8ac7b7b5c61e4b07468c7d Mon Sep 17 00:00:00 2001 From: MathisGredtYnov <113118860+MathisGredtYnov@users.noreply.github.com> Date: Mon, 24 Nov 2025 14:39:04 +0100 Subject: [PATCH 3/9] =?UTF-8?q?Add=20irradiated=20particle=20effects=20and?= =?UTF-8?q?=20integrate=20into=20biome=20settings=20(=C3=A7a=20marche=20pr?= =?UTF-8?q?esque)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../worldgen/biome/irradiated_plain.json | 2 +- .../createnuclear/CreateNuclear.java | 2 + .../content/particles/CNParticleTypes.java | 91 ++++++++++++++++++ .../particles/IrradiatedParticles.java | 50 ++++++++++ .../particles/IrradiatedParticlesData.java | 83 ++++++++++++++++ .../worldgen/biome/CNBiomes.java | 12 +-- .../particles/irradiated_particles.json | 5 + .../particle/irradiated_particles.png | Bin 0 -> 516 bytes 8 files changed, 238 insertions(+), 7 deletions(-) create mode 100644 src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticles.java create mode 100644 src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java create mode 100644 src/main/resources/assets/createnuclear/particles/irradiated_particles.json create mode 100644 src/main/resources/assets/createnuclear/textures/particle/irradiated_particles.png diff --git a/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json index aa80c921..706efd34 100644 --- a/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json +++ b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json @@ -15,7 +15,7 @@ "water_color": 4159204, "particle": { "options": { - "type": "minecraft:crimson_spore" + "type": "createnuclear:irradiated_particles" }, "probability": 0.025 }, diff --git a/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java b/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java index 0a00d94f..aac4f6f0 100644 --- a/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java +++ b/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java @@ -25,6 +25,7 @@ import net.nuclearteam.createnuclear.content.contraptions.irradiated.IrradiatedAnimal; import net.nuclearteam.createnuclear.content.decoration.palettes.CNPaletteBlocks; import net.nuclearteam.createnuclear.content.kinetics.fan.processing.CNFanProcessingTypes; +import net.nuclearteam.createnuclear.content.particles.CNParticleTypes; import net.nuclearteam.createnuclear.infrastructure.config.CNConfigs; import net.nuclearteam.createnuclear.infrastructure.data.CreateNuclearDatagen; import org.slf4j.Logger; @@ -72,6 +73,7 @@ public static void onInitialize() { CNCreativeModeTabs.register(modEventBus); CNEffects.register(modEventBus); CNPotions.register(modEventBus); + CNParticleTypes.register(modEventBus); CNRecipeTypes.register(modEventBus); CNAttributes.register(modEventBus); diff --git a/src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java b/src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java new file mode 100644 index 00000000..77482dac --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java @@ -0,0 +1,91 @@ +package net.nuclearteam.createnuclear.content.particles; + +import com.simibubi.create.AllParticleTypes; +import com.simibubi.create.foundation.particle.ICustomParticleData; +import net.createmod.catnip.lang.Lang; +import net.minecraft.core.Registry; +import net.minecraft.network.FriendlyByteBuf; +import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.api.distmarker.OnlyIn; +import net.minecraftforge.client.event.RegisterParticleProvidersEvent; +import net.minecraftforge.registries.DeferredRegister; +import net.minecraftforge.registries.ForgeRegistries; +import net.minecraftforge.registries.RegistryObject; +import net.createmod.catnip.lang.Lang; +import net.minecraftforge.eventbus.api.IEventBus; +import net.minecraft.client.Minecraft; +import net.minecraft.client.particle.ParticleEngine; +import net.minecraft.core.particles.ParticleOptions; +import net.minecraft.core.particles.ParticleType; +import net.minecraft.core.registries.BuiltInRegistries; +import net.nuclearteam.createnuclear.CreateNuclear; + +import java.util.function.Supplier; + +public enum CNParticleTypes implements ParticleOptions { + IRRADIATED_PARTICLES(IrradiatedParticlesData::new), + ; + + private final ParticleEntry entry; + + CNParticleTypes(Supplier> typeFactory) { + String name = Lang.asId(name()); + entry = new ParticleEntry<>(name, typeFactory); + } + + public static void register(IEventBus modEventBus) { + ParticleEntry.REGISTER.register(modEventBus); + } + + @OnlyIn(Dist.CLIENT) + public static void registerFactories(RegisterParticleProvidersEvent event) { + for (CNParticleTypes particle : values()) + particle.entry.registerFactory(event); + } + + public ParticleType get() { + return entry.object.get(); + } + + public String parameter() { + return entry.name; + } + + @Override + public ParticleType getType() { + return null; + } + + @Override + public void writeToNetwork(FriendlyByteBuf pBuffer) { + + } + + @Override + public String writeToString() { + return ""; + } + + private static class ParticleEntry { + private static final DeferredRegister> REGISTER = DeferredRegister.create(ForgeRegistries.PARTICLE_TYPES, CreateNuclear.MOD_ID); + + private final String name; + private final Supplier> typeFactory; + private final RegistryObject> object; + + public ParticleEntry(String name, Supplier> typeFactory) { + this.name = name; + this.typeFactory = typeFactory; + + object = REGISTER.register(name, () -> this.typeFactory.get().createType()); + } + + + + @OnlyIn(Dist.CLIENT) + public void registerFactory(RegisterParticleProvidersEvent event) { + typeFactory.get() + .register(object.get(), event); + } + } +} diff --git a/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticles.java b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticles.java new file mode 100644 index 00000000..e199d6a0 --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticles.java @@ -0,0 +1,50 @@ +package net.nuclearteam.createnuclear.content.particles; + +import net.minecraft.client.multiplayer.ClientLevel; +import net.minecraft.client.particle.*; +import net.minecraft.util.RandomSource; + +import javax.annotation.Nullable; + +public class IrradiatedParticles extends TextureSheetParticle { + protected IrradiatedParticles(ClientLevel pLevel, double pX, double pY, double pZ, + SpriteSet spriteSet, double pXSpeed, double pYSpeed, double pZSpeed) { + super(pLevel, pX, pY, pZ, pXSpeed, pYSpeed, pZSpeed); + + RandomSource randomSource = level.random; + + this.xo = randomSource.nextGaussian() * (double)1.0E-6f; + this.yo = randomSource.nextGaussian() * (double)1.0E-4f; + this.zo = randomSource.nextGaussian() * (double)1.0E-6f; + + this.quadSize *= this.random.nextFloat() * 0.6f + 0.6f; + this.hasPhysics = false; + this.gravity = 0.0f; + + this.friction = 0.8f; + this.lifetime = 40; + + this.setSpriteFromAge(spriteSet); + + } + + @Override + public ParticleRenderType getRenderType() { + return ParticleRenderType.PARTICLE_SHEET_TRANSLUCENT; + } + + public static class Provider implements ParticleProvider { + private final SpriteSet spriteSet; + + public Provider(SpriteSet spriteSet) { + this.spriteSet = spriteSet; + } + + @Nullable + @Override + public Particle createParticle(IrradiatedParticlesData pType, ClientLevel pLevel, double pX, double pY, double pZ, + double pXSpeed, double pYSpeed, double pZSpeed) { + return new IrradiatedParticles(pLevel, pX, pY, pZ, this.spriteSet, pXSpeed, pYSpeed, pZSpeed); + } + } +} diff --git a/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java new file mode 100644 index 00000000..939375bf --- /dev/null +++ b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java @@ -0,0 +1,83 @@ +package net.nuclearteam.createnuclear.content.particles; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.serialization.Codec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import com.simibubi.create.foundation.particle.ICustomParticleDataWithSprite; +import net.minecraft.client.particle.ParticleEngine.SpriteParticleRegistration; +import net.minecraft.core.particles.ParticleOptions; +import net.minecraft.core.particles.ParticleType; +import net.minecraft.network.FriendlyByteBuf; + +import java.util.Locale; + +public class IrradiatedParticlesData implements ParticleOptions, ICustomParticleDataWithSprite { + + public static final Codec CODEC = RecordCodecBuilder.create(i -> + i.group( + Codec.INT.fieldOf("t").forGetter(p -> p.t) + ) + .apply(i, IrradiatedParticlesData::new) + ); + + public static final Deserializer DESERIALIZER = + new Deserializer<>() { + @Override + public IrradiatedParticlesData fromCommand(ParticleType particleType, StringReader reader) throws CommandSyntaxException { + return new IrradiatedParticlesData(); + } + + @Override + public IrradiatedParticlesData fromNetwork(ParticleType particleType, FriendlyByteBuf buffer) { + return new IrradiatedParticlesData(); + } + }; + + + int t; + + public IrradiatedParticlesData(int _t) { + t = _t; + } + + public IrradiatedParticlesData() { + this(0); + } + + @Override + public ParticleType getType() { + return CNParticleTypes.IRRADIATED_PARTICLES.get(); + } + + @Override + public void writeToNetwork(FriendlyByteBuf buffer) { + buffer.writeInt(t); + } + + @Override + public String writeToString() { + return String.format(Locale.ROOT, "%s %d", CNParticleTypes.IRRADIATED_PARTICLES.parameter(), t); + } + + @Override + public Deserializer getDeserializer() { + return DESERIALIZER; + } + + @Override + public Codec getCodec(ParticleType type) { + return CODEC; + } + + @Override + public SpriteParticleRegistration getMetaFactory() { + return IrradiatedParticles.Provider::new; + } + + + + + + +} diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java index 390fe6fc..9b8e2b51 100644 --- a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java @@ -1,7 +1,6 @@ package net.nuclearteam.createnuclear.infrastructure.worldgen.biome; import net.minecraft.core.HolderGetter; -import net.minecraft.core.particles.ParticleTypes; import net.minecraft.core.registries.Registries; import net.minecraft.data.worldgen.BootstapContext; import net.minecraft.resources.ResourceKey; @@ -10,6 +9,7 @@ import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; import net.minecraft.world.level.levelgen.placement.PlacedFeature; import net.nuclearteam.createnuclear.CreateNuclear; +import net.nuclearteam.createnuclear.content.particles.CNParticleTypes; import org.jetbrains.annotations.NotNull; public class CNBiomes { @@ -25,11 +25,11 @@ public static Biome irradiatedPlain(HolderGetter holderGetter, Ho BiomeGenerationSettings.Builder genSettings = new BiomeGenerationSettings.Builder(holderGetter, holder2); BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); effects - .fogColor(0) - .ambientParticle(new AmbientParticleSettings(ParticleTypes.CRIMSON_SPORE, 0.025F)) - .waterColor(4159204) - .waterFogColor(329011) - .skyColor(0) + .fogColor(0) + .ambientParticle(new AmbientParticleSettings(CNParticleTypes.IRRADIATED_PARTICLES, 0.025F)) + .waterColor(4159204) + .waterFogColor(329011) + .skyColor(0) ; return builder .downfall(0) diff --git a/src/main/resources/assets/createnuclear/particles/irradiated_particles.json b/src/main/resources/assets/createnuclear/particles/irradiated_particles.json new file mode 100644 index 00000000..4c09429a --- /dev/null +++ b/src/main/resources/assets/createnuclear/particles/irradiated_particles.json @@ -0,0 +1,5 @@ +{ + "textures": [ + "createnuclear:irradiated_particles" + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/createnuclear/textures/particle/irradiated_particles.png b/src/main/resources/assets/createnuclear/textures/particle/irradiated_particles.png new file mode 100644 index 0000000000000000000000000000000000000000..c3e80185fade017cb90fd403d536cf36187e7e19 GIT binary patch literal 516 zcmeAS@N?(olHy`uVBq!ia0vp^93afW1|*O0@9PFqEa{HEjtmSN`?>!lvI6;>1s;*b z3=DjSK$uZf!>fUTfw4U^B%&n3*T*V3KUXg?B|j-uuOhbqsG5Pn#=fE;F*!T6L?J0P zJu}Z%{r&F!>I#`Dw(8-gz6QPp&Z!xh9#uuD!Bu`C$yM3OmMQA?cD!6R6;?nKa#KqZ z6)JLb@`|l0Y?Z(UTLIZ1VSOb#o1&C7s~{IQs0tv@Rw<*Tq`*pFzr4I$uiRKKzbIYb z(9+UU-@r)U$VeBcLbtdwuOzWTH?LS3YJf{>adJ^+K}lwQo&w0g#H9Sv5?iIx(##aA zw8S*iq?8m>-K0e06kS8ZltkUc6k|i(6l3EQb5lbLqcp=LC8+f!nP~|7^NOLt01Oa) zkc_^eo&m_oAhwl%QD!R86(B3^3~j*jC}KAHAcr71%nl*~^ed1B4;fG}!9zDS4;ZB7 zz_8PqGJ_i!?!ulfjv*Ss$q5oY5B7hoFHw|YX85s^$!O~`Pb*Noc)I$ztaD0e0st?$ BpqBsu literal 0 HcmV?d00001 From a1709076c23c7ca27d20263d01e8c6eef8d618c1 Mon Sep 17 00:00:00 2001 From: Giovanni Date: Mon, 24 Nov 2025 19:53:22 +0100 Subject: [PATCH 4/9] Add CNParticleTypes and integrate irradiated particle data into the system --- .../particles => }/CNParticleTypes.java | 28 ++--------------- .../createnuclear/CreateNuclear.java | 1 - .../createnuclear/CreateNuclearClient.java | 1 + .../bluePrintItem/ReactorBluePrintMenu.java | 6 ++-- .../particles/IrradiatedParticlesData.java | 31 ++++++++++--------- 5 files changed, 24 insertions(+), 43 deletions(-) rename src/main/java/net/nuclearteam/createnuclear/{content/particles => }/CNParticleTypes.java (77%) diff --git a/src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java b/src/main/java/net/nuclearteam/createnuclear/CNParticleTypes.java similarity index 77% rename from src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java rename to src/main/java/net/nuclearteam/createnuclear/CNParticleTypes.java index 77482dac..00d41dd8 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/particles/CNParticleTypes.java +++ b/src/main/java/net/nuclearteam/createnuclear/CNParticleTypes.java @@ -1,9 +1,7 @@ -package net.nuclearteam.createnuclear.content.particles; +package net.nuclearteam.createnuclear; -import com.simibubi.create.AllParticleTypes; import com.simibubi.create.foundation.particle.ICustomParticleData; import net.createmod.catnip.lang.Lang; -import net.minecraft.core.Registry; import net.minecraft.network.FriendlyByteBuf; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; @@ -11,18 +9,14 @@ import net.minecraftforge.registries.DeferredRegister; import net.minecraftforge.registries.ForgeRegistries; import net.minecraftforge.registries.RegistryObject; -import net.createmod.catnip.lang.Lang; import net.minecraftforge.eventbus.api.IEventBus; -import net.minecraft.client.Minecraft; -import net.minecraft.client.particle.ParticleEngine; import net.minecraft.core.particles.ParticleOptions; import net.minecraft.core.particles.ParticleType; -import net.minecraft.core.registries.BuiltInRegistries; -import net.nuclearteam.createnuclear.CreateNuclear; +import net.nuclearteam.createnuclear.content.particles.IrradiatedParticlesData; import java.util.function.Supplier; -public enum CNParticleTypes implements ParticleOptions { +public enum CNParticleTypes { IRRADIATED_PARTICLES(IrradiatedParticlesData::new), ; @@ -51,20 +45,6 @@ public String parameter() { return entry.name; } - @Override - public ParticleType getType() { - return null; - } - - @Override - public void writeToNetwork(FriendlyByteBuf pBuffer) { - - } - - @Override - public String writeToString() { - return ""; - } private static class ParticleEntry { private static final DeferredRegister> REGISTER = DeferredRegister.create(ForgeRegistries.PARTICLE_TYPES, CreateNuclear.MOD_ID); @@ -80,8 +60,6 @@ public ParticleEntry(String name, Supplier> typ object = REGISTER.register(name, () -> this.typeFactory.get().createType()); } - - @OnlyIn(Dist.CLIENT) public void registerFactory(RegisterParticleProvidersEvent event) { typeFactory.get() diff --git a/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java b/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java index aac4f6f0..c5f73f93 100644 --- a/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java +++ b/src/main/java/net/nuclearteam/createnuclear/CreateNuclear.java @@ -25,7 +25,6 @@ import net.nuclearteam.createnuclear.content.contraptions.irradiated.IrradiatedAnimal; import net.nuclearteam.createnuclear.content.decoration.palettes.CNPaletteBlocks; import net.nuclearteam.createnuclear.content.kinetics.fan.processing.CNFanProcessingTypes; -import net.nuclearteam.createnuclear.content.particles.CNParticleTypes; import net.nuclearteam.createnuclear.infrastructure.config.CNConfigs; import net.nuclearteam.createnuclear.infrastructure.data.CreateNuclearDatagen; import org.slf4j.Logger; diff --git a/src/main/java/net/nuclearteam/createnuclear/CreateNuclearClient.java b/src/main/java/net/nuclearteam/createnuclear/CreateNuclearClient.java index fbf15823..c5c91c36 100644 --- a/src/main/java/net/nuclearteam/createnuclear/CreateNuclearClient.java +++ b/src/main/java/net/nuclearteam/createnuclear/CreateNuclearClient.java @@ -10,6 +10,7 @@ public class CreateNuclearClient { public static void onCtorClient(IEventBus modEventBus, IEventBus forgeEventBus) { modEventBus.addListener(CreateNuclearClient::clientInit); + modEventBus.addListener(CNParticleTypes::registerFactories); } diff --git a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/bluePrintItem/ReactorBluePrintMenu.java b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/bluePrintItem/ReactorBluePrintMenu.java index a6406ae2..b9b5cfdb 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/bluePrintItem/ReactorBluePrintMenu.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/bluePrintItem/ReactorBluePrintMenu.java @@ -11,6 +11,8 @@ import net.minecraft.world.item.Items; import net.minecraftforge.api.distmarker.Dist; import net.minecraftforge.api.distmarker.OnlyIn; +import net.minecraftforge.items.ItemStackHandler; +import net.minecraftforge.items.SlotItemHandler; import net.nuclearteam.createnuclear.CNMenus; import net.nuclearteam.createnuclear.CNTags; @@ -66,7 +68,7 @@ protected void initAndReadInventory(ItemStack contentHolder) { } @Override - protected net.minecraftforge.items.ItemStackHandler createGhostInventory() { + protected ItemStackHandler createGhostInventory() { return getItemStorage(contentHolder); } @@ -100,7 +102,7 @@ private void addPatternSlots() { }; for (int[] pos : positions) {// up and down not middle - this.addSlot(new net.minecraftforge.items.SlotItemHandler(ghostInventory,i, startWidth + incr * pos[0], startHeight + incr * pos[1])); + this.addSlot(new SlotItemHandler(ghostInventory,i, startWidth + incr * pos[0], startHeight + incr * pos[1])); i++; } } diff --git a/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java index 939375bf..feec3db6 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/particles/IrradiatedParticlesData.java @@ -9,30 +9,31 @@ import net.minecraft.core.particles.ParticleOptions; import net.minecraft.core.particles.ParticleType; import net.minecraft.network.FriendlyByteBuf; +import net.nuclearteam.createnuclear.CNParticleTypes; import java.util.Locale; public class IrradiatedParticlesData implements ParticleOptions, ICustomParticleDataWithSprite { public static final Codec CODEC = RecordCodecBuilder.create(i -> - i.group( - Codec.INT.fieldOf("t").forGetter(p -> p.t) - ) - .apply(i, IrradiatedParticlesData::new) + i.group( + Codec.INT.fieldOf("t").forGetter(p -> p.t) + ) + .apply(i, IrradiatedParticlesData::new) ); public static final Deserializer DESERIALIZER = - new Deserializer<>() { - @Override - public IrradiatedParticlesData fromCommand(ParticleType particleType, StringReader reader) throws CommandSyntaxException { - return new IrradiatedParticlesData(); - } - - @Override - public IrradiatedParticlesData fromNetwork(ParticleType particleType, FriendlyByteBuf buffer) { - return new IrradiatedParticlesData(); - } - }; + new Deserializer<>() { + @Override + public IrradiatedParticlesData fromCommand(ParticleType particleType, StringReader reader) throws CommandSyntaxException { + return new IrradiatedParticlesData(); + } + + @Override + public IrradiatedParticlesData fromNetwork(ParticleType particleType, FriendlyByteBuf buffer) { + return new IrradiatedParticlesData(); + } + }; int t; From d6f73791a104420fd142e76a7edcb08c67080812 Mon Sep 17 00:00:00 2001 From: Giovanni Date: Mon, 24 Nov 2025 19:54:00 +0100 Subject: [PATCH 5/9] Refactor ambient particle settings in CNBiomes to use IrradiatedParticlesData --- .../infrastructure/worldgen/biome/CNBiomes.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java index 9b8e2b51..8270dd74 100644 --- a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java @@ -9,7 +9,8 @@ import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; import net.minecraft.world.level.levelgen.placement.PlacedFeature; import net.nuclearteam.createnuclear.CreateNuclear; -import net.nuclearteam.createnuclear.content.particles.CNParticleTypes; +import net.nuclearteam.createnuclear.CNParticleTypes; +import net.nuclearteam.createnuclear.content.particles.IrradiatedParticlesData; import org.jetbrains.annotations.NotNull; public class CNBiomes { @@ -26,7 +27,7 @@ public static Biome irradiatedPlain(HolderGetter holderGetter, Ho BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); effects .fogColor(0) - .ambientParticle(new AmbientParticleSettings(CNParticleTypes.IRRADIATED_PARTICLES, 0.025F)) +// .ambientParticle(new AmbientParticleSettings(new IrradiatedParticlesData(), 1F)) .waterColor(4159204) .waterFogColor(329011) .skyColor(0) From 1c537da729974da6109247d449fe63358aa2726c Mon Sep 17 00:00:00 2001 From: Giovanni Date: Mon, 24 Nov 2025 20:44:22 +0100 Subject: [PATCH 6/9] Update irradiated_plain biome configuration for particle settings and metadata --- .../.cache/fed443662143001aeb5341375f6f5ef31d10baea | 4 ++-- .../createnuclear/worldgen/biome/irradiated_plain.json | 7 ++++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea b/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea index 5cebb33b..cc4df587 100644 --- a/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea +++ b/src/generated/resources/.cache/fed443662143001aeb5341375f6f5ef31d10baea @@ -1,8 +1,8 @@ -// 1.20.1 2025-11-23T12:40:21.151147 CreateNuclear Generated Registry Entries +// 1.20.1 2025-11-24T20:36:32.0462092 CreateNuclear Generated Registry Entries 5edbd74546f4088818e02bb7a5c5eb2ecfe25623 data/createnuclear/forge/biome_modifier/lead_ore.json 72173023e6a31748692e750db0f5fa8c555d1009 data/createnuclear/forge/biome_modifier/striated_ores_overworld.json fa32145101dc12ec914684fec8c5cbb995d2c051 data/createnuclear/forge/biome_modifier/uranium_ore.json -7e7b325ead2c18ad373126b3fed8f2a5b09190e2 data/createnuclear/worldgen/biome/irradiated_plain.json +bec3aa19be2740b8347902856a2ad920b0641804 data/createnuclear/worldgen/biome/irradiated_plain.json b68555f371c9700aa4ecfa9370b010de8fe25b60 data/createnuclear/worldgen/configured_feature/lead_ore.json 4f11c0a518c0de7857919983fc638ba551c6630a data/createnuclear/worldgen/configured_feature/striated_ores_overworld.json b0e1ee7314412507fd7346cb48b29d105f6186ad data/createnuclear/worldgen/configured_feature/uranium_ore.json diff --git a/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json index 706efd34..0e531893 100644 --- a/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json +++ b/src/generated/resources/data/createnuclear/worldgen/biome/irradiated_plain.json @@ -11,14 +11,15 @@ "sound": "minecraft:ambient.cave", "tick_delay": 6000 }, - "sky_color": 0, - "water_color": 4159204, "particle": { "options": { - "type": "createnuclear:irradiated_particles" + "type": "createnuclear:irradiated_particles", + "t": 0 }, "probability": 0.025 }, + "sky_color": 0, + "water_color": 4159204, "water_fog_color": 329011 }, "features": [ From 41d8be0725d5c56bfa73ff70b0ac4e464c7f6322 Mon Sep 17 00:00:00 2001 From: Giovanni Date: Mon, 24 Nov 2025 20:44:34 +0100 Subject: [PATCH 7/9] Refactor irradiated biome setup to use IrradiatedBiomes.createPlain and add ambient particle effects --- .../worldgen/biome/CNBiomes.java | 28 ------------------- .../worldgen/biome/IrradiatedBiomes.java | 2 ++ 2 files changed, 2 insertions(+), 28 deletions(-) diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java index 8270dd74..e20dbd6b 100644 --- a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/CNBiomes.java @@ -4,13 +4,10 @@ import net.minecraft.core.registries.Registries; import net.minecraft.data.worldgen.BootstapContext; import net.minecraft.resources.ResourceKey; -import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.biome.*; import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; import net.minecraft.world.level.levelgen.placement.PlacedFeature; import net.nuclearteam.createnuclear.CreateNuclear; -import net.nuclearteam.createnuclear.CNParticleTypes; -import net.nuclearteam.createnuclear.content.particles.IrradiatedParticlesData; import org.jetbrains.annotations.NotNull; public class CNBiomes { @@ -18,35 +15,10 @@ public static final class Irradiated { public static final ResourceKey PLAIN = key("irradiated_plain"); } - public static final ResourceKey IRRADIATED_PLAIN = ResourceKey.create(Registries.BIOME, new ResourceLocation("irradiated_plain")); - - public static Biome irradiatedPlain(HolderGetter holderGetter, HolderGetter> holder2) { - Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - MobSpawnSettings.Builder spawn = new MobSpawnSettings.Builder(); - BiomeGenerationSettings.Builder genSettings = new BiomeGenerationSettings.Builder(holderGetter, holder2); - BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - effects - .fogColor(0) -// .ambientParticle(new AmbientParticleSettings(new IrradiatedParticlesData(), 1F)) - .waterColor(4159204) - .waterFogColor(329011) - .skyColor(0) - ; - return builder - .downfall(0) - .temperature(1) - .specialEffects(effects.build()) - .mobSpawnSettings(spawn.build()) - .hasPrecipitation(false) - .generationSettings(genSettings.build()) - .temperatureAdjustment(Biome.TemperatureModifier.NONE).build(); - } - public static void bootstrapRegistries(BootstapContext context) { HolderGetter featureLookup = context.lookup(Registries.PLACED_FEATURE); HolderGetter> carverLookup = context.lookup(Registries.CONFIGURED_CARVER); - context.register(IRRADIATED_PLAIN, irradiatedPlain(context.lookup(Registries.PLACED_FEATURE), context.lookup(Registries.CONFIGURED_CARVER))); context.register(Irradiated.PLAIN, IrradiatedBiomes.createPlain(featureLookup, carverLookup)); } diff --git a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java index 4c5cfa69..7b067fb6 100644 --- a/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java +++ b/src/main/java/net/nuclearteam/createnuclear/infrastructure/worldgen/biome/IrradiatedBiomes.java @@ -9,6 +9,7 @@ import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver; import net.minecraft.world.level.levelgen.placement.PlacedFeature; import net.nuclearteam.createnuclear.CNEntityType; +import net.nuclearteam.createnuclear.content.particles.IrradiatedParticlesData; public class IrradiatedBiomes { public static Biome createPlain(HolderGetter featureLookup, HolderGetter> carverLookup) { @@ -37,6 +38,7 @@ public static Biome irradiated(HolderGetter featureGetter, Holder .waterFogColor(329011) .fogColor(329011) .skyColor(0) + .ambientParticle(new AmbientParticleSettings(new IrradiatedParticlesData(), 0.025F)) .ambientMoodSound(AmbientMoodSettings.LEGACY_CAVE_SETTINGS) ; From fa75eb729d7cd2613b3c520a63347f16427d78ce Mon Sep 17 00:00:00 2001 From: Giovanni Date: Sun, 28 Dec 2025 18:13:05 +0100 Subject: [PATCH 8/9] Refactor biome change logic in ReactorCasing to use BlockPos and improve chunk processing Co-authored-by: MathisGredtYnov <113118860+MathisGredtYnov@users.noreply.github.com> Co-authored-by: ArcEnStone <113118860+MathisGredt@users.noreply.github.com> Co-authored-by: MathisGredtYnov --- .../multiblock/casing/ReactorCasing.java | 47 +++++++++---------- 1 file changed, 21 insertions(+), 26 deletions(-) diff --git a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java index bc0c269f..63dfe673 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java @@ -47,7 +47,6 @@ @SuppressWarnings({"deprecation", "unused"}) public class ReactorCasing extends Block implements IWrenchable, IBE { private final TypeBlock typeBlock; - public boolean biomeUnchanged = true; public ReactorCasing(Properties properties, TypeBlock tBlock) { super(properties); @@ -58,7 +57,8 @@ public ReactorCasing(Properties properties, TypeBlock tBlock) { @Override // Called when the block is placed on the world public void onPlace(BlockState state, Level level, BlockPos pos, BlockState oldState, boolean movedByPiston) { super.onPlace(state, level, pos, oldState, movedByPiston); - changeBiome(CNBiomes.Irradiated.PLAIN, 12, new Vec3(5, 5, 5), (ServerLevel) level); + // change nearby chunks' biomes to the mod biome (radius in blocks) + changeBiome(CNBiomes.Irradiated.PLAIN, 12, pos, (ServerLevel) level); List players = level.players(); FindController(pos, level, players, true); } @@ -116,36 +116,31 @@ public static Vec3i floorAll(double x, double y, double z) { return new Vec3i(Mth.floor(x), Mth.floor(y), Mth.floor(z)); } - public void changeBiome(ResourceKey biomeResourceKey, int pass, Vec3 effectCenter, ServerLevel serverLevel) { - CreateNuclear.LOGGER.info("ReactorBlock.changeBiome: {}", biomeUnchanged); - if(!biomeUnchanged) return; - double range = 300; - double passes = 13; - BoundingBox boundingbox = BoundingBox.fromCorners(floorAll(300 + (passes - 1) * 5.0 + effectCenter.x, 300 + (passes - 1) * 5.0 + effectCenter.y, range + (passes - 1) * 5.0 + effectCenter.z), floorAll(effectCenter.x - range + (passes - 1) * 5.0, effectCenter.y - range + (passes - 1) * 5.0, effectCenter.z - range + (passes - 1) * 5.0)); + public void changeBiome(ResourceKey biomeResourceKey, int radius, BlockPos center, ServerLevel serverLevel) { + // radius is in blocks; we convert to chunk/section coords + Registry biomeRegistry = serverLevel.registryAccess().registryOrThrow(Registries.BIOME); + Holder biomeHolder = biomeRegistry.getHolderOrThrow(biomeResourceKey); + + int minX = center.getX() - radius; + int maxX = center.getX() + radius; + int minZ = center.getZ() - radius; + int maxZ = center.getZ() + radius; + ArrayList chunks = new ArrayList<>(); - CreateNuclear.LOGGER.info("ReactorBlock.change: {}", boundingbox); - for (int k = SectionPos.blockToSectionCoord(boundingbox.minZ()); k <= SectionPos.blockToSectionCoord(boundingbox.maxZ()); ++k) { - CreateNuclear.LOGGER.warn("ReactorBlock.for (int k =: {}", k); - for (int l = SectionPos.blockToSectionCoord(boundingbox.minX()); l <= SectionPos.blockToSectionCoord(boundingbox.maxX()); ++l) { - CreateNuclear.LOGGER.warn("ReactorBlock.int l =: {}, serverLevel.getChunk; {}", l, serverLevel.getChunk(l, k, ChunkStatus.FULL, false)); - ChunkAccess chunkAccess = serverLevel.getChunk(l, k, ChunkStatus.FULL, false); - if (chunkAccess != null) + + for (int cz = SectionPos.blockToSectionCoord(minZ); cz <= SectionPos.blockToSectionCoord(maxZ); ++cz) { + for (int cx = SectionPos.blockToSectionCoord(minX); cx <= SectionPos.blockToSectionCoord(maxX); ++cx) { + ChunkAccess chunkAccess = serverLevel.getChunk(cx, cz, ChunkStatus.FULL, false); + if (chunkAccess != null) { + chunkAccess.fillBiomesFromNoise(makeResolver(biomeHolder), serverLevel.getChunkSource().randomState().sampler()); + chunkAccess.setUnsaved(true); chunks.add(chunkAccess); + } } } - for (ChunkAccess chunkAccess : chunks) { - CreateNuclear.LOGGER.warn("test change biome chunk: {}", chunkAccess.getPos()); - Registry biomeRegistry = serverLevel.registryAccess().registryOrThrow(Registries.BIOME); - Biome biome = biomeRegistry.get(biomeResourceKey); - assert biome != null; - chunkAccess.fillBiomesFromNoise(makeResolver(biomeRegistry.wrapAsHolder(biome)), serverLevel.getChunkSource().randomState().sampler()); - chunkAccess.setUnsaved(true); - } - + // Inform players/clients about biome changes for affected chunks serverLevel.getChunkSource().chunkMap.resendBiomesForChunks(chunks); - biomeUnchanged = false; - } public static BiomeResolver makeResolver(Holder biomeHolder) { From 290fbfc83b8c9e0bf2c3d0386893a00a1765e03e Mon Sep 17 00:00:00 2001 From: Giovanni Date: Sun, 28 Dec 2025 18:28:35 +0100 Subject: [PATCH 9/9] Add check to skip biome change if already set to target biome in ReactorCasing Co-authored-by: MathisGredtYnov <113118860+MathisGredtYnov@users.noreply.github.com> Co-authored-by: ArcEnStone <113118860+MathisGredt@users.noreply.github.com> Co-authored-by: MathisGredtYnov --- .../content/multiblock/casing/ReactorCasing.java | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java index 63dfe673..9f732b96 100644 --- a/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java +++ b/src/main/java/net/nuclearteam/createnuclear/content/multiblock/casing/ReactorCasing.java @@ -41,6 +41,7 @@ import javax.annotation.ParametersAreNonnullByDefault; import java.util.ArrayList; import java.util.List; +import java.util.Optional; @ParametersAreNonnullByDefault @MethodsReturnNonnullByDefault @@ -112,15 +113,19 @@ public ReactorControllerBlock FindController(BlockPos blockPos, Level level, Lis return null; } - public static Vec3i floorAll(double x, double y, double z) { - return new Vec3i(Mth.floor(x), Mth.floor(y), Mth.floor(z)); - } - public void changeBiome(ResourceKey biomeResourceKey, int radius, BlockPos center, ServerLevel serverLevel) { // radius is in blocks; we convert to chunk/section coords Registry biomeRegistry = serverLevel.registryAccess().registryOrThrow(Registries.BIOME); Holder biomeHolder = biomeRegistry.getHolderOrThrow(biomeResourceKey); + // If the center biome is already the target biome, skip whole operation + Holder current = serverLevel.getBiome(center); + Optional> currentKey = current.unwrapKey(); + if (currentKey.isPresent() && currentKey.get().equals(biomeResourceKey)) { + CreateNuclear.LOGGER.info("changeBiome: center already irradiated: {}", currentKey.get()); + return; + } + int minX = center.getX() - radius; int maxX = center.getX() + radius; int minZ = center.getZ() - radius;