notes refactor part 2

src/main/java/net/lerariemann/infinity/block/custom/NotesBlock.java

···
-package net.lerariemann.infinity.block.custom;
-
-import net.lerariemann.infinity.block.entity.ChromaticBlockEntity;
-import net.lerariemann.infinity.options.InfinityOptions;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.particles.ParticleTypes;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.stats.Stats;
-import net.minecraft.util.RandomSource;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.NoteBlock;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.StateDefinition;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
-import net.minecraft.world.level.block.state.properties.BooleanProperty;
-import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
-import net.minecraft.world.level.gameevent.GameEvent;
-//? if >1.21.4 {
-import net.minecraft.world.level.redstone.Orientation;
-//?}
-import net.minecraft.world.phys.BlockHitResult;
-import org.jetbrains.annotations.Nullable;
-
-public class NotesBlock extends Block {
-    public static final BooleanProperty POWERED = BlockStateProperties.POWERED;
-    public static final BooleanProperty TICKING = BooleanProperty.create("ticking");
-    public NotesBlock(Properties settings) {
-        super(settings);
-        this.registerDefaultState(this.defaultBlockState().setValue(POWERED, false).setValue(TICKING, true));
-    }
-
-    @Override
-    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
-        super.createBlockStateDefinition(builder);
-        builder.add(POWERED);
-        builder.add(TICKING);
-    }
-
-    @Override
-    //? if >1.21 {
-    protected
-    //?} else {
-    /*public
-    *///?}
-    boolean isRandomlyTicking(BlockState state) {
-        return state.hasProperty(TICKING) && state.getValue(TICKING);
-    }
-
-    @Override
-    //? if >1.21 {
-    protected
-     //?} else {
-    /*public
-        *///?}
-    void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock,
-                         //? if >1.21.2 {
-                         Orientation orientation
-                         //?} else {
-                          /*BlockPos sourcePos
-                         *///?}
-            , boolean notify) {
-        boolean bl = world.hasNeighborSignal(pos);
-        if (bl != state.getValue(POWERED)) {
-            if (bl) this.play(null, world, pos);
-            world.setBlock(pos, state.setValue(POWERED, bl), 3);
-        }
-    }
-
-    public boolean isTicking(ServerLevel world, BlockState state) {
-        return state.getValue(TICKING) && (!InfinityOptions.access(world).isHaunted());
-    }
-
-    @Override
-    //? if >1.21 {
-    protected
-     //?} else {
-    /*public
-    *///?}
-     void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-        if (isTicking(world, state) && random.nextInt(115) == 0) {
-            this.play(null, world, pos);
-        }
-    }
-    
-    @Override
-    //? if <1.21 {
-    /*public InteractionResult use(BlockState state, Level world, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hit) {
-        *///?} else {
-    protected InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player, BlockHitResult hit) {
-        //?}
-        if (world.isClientSide()) {
-            return InteractionResult.SUCCESS;
-        } else {
-            boolean bl = state.getValue(TICKING);
-            world.setBlock(pos, state.setValue(TICKING, !bl), 3);
-            play(player, world, pos);
-            player.awardStat(Stats.TUNE_NOTEBLOCK);
-            return InteractionResult.CONSUME;
-        }
-    }
-
-    @Override
-    //? if >1.21 {
-    protected
-     //?} else {
-    /*public
-        *///?}
-     void attack(BlockState state, Level world, BlockPos pos, Player player) {
-        if (!world.isClientSide()) {
-            play(player, world, pos);
-            player.awardStat(Stats.PLAY_NOTEBLOCK);
-        }
-    }
-
-    public void play(@Nullable Entity entity, Level world, BlockPos pos) {
-        if (world.getBlockState(pos.above()).isAir()) {
-            world.blockEvent(pos, this, 0, 0);
-            world.gameEvent(entity, GameEvent.NOTE_BLOCK_PLAY, pos);
-        }
-    }
-
-    @Override
-    //? if >1.21 {
-    protected
-     //?} else {
-    /*public
-        *///?}
-     boolean triggerEvent(BlockState state, Level world, BlockPos pos, int type, int data) {
-        NoteBlockInstrument noteBlockInstrument;
-        float f;
-        if (world.getBlockEntity(pos.below()) instanceof ChromaticBlockEntity e) {
-            noteBlockInstrument = NoteBlockInstrument.GUITAR;
-            f = (float)Math.pow(2.0, 2 * (e.brightness / 255f) - 1);
-        }
-        else {
-            NoteBlockInstrument[] instruments = NoteBlockInstrument.values();
-            noteBlockInstrument = instruments[world.random.nextInt(instruments.length-7)];
-            if (noteBlockInstrument.isTunable()) {
-                int i = world.random.nextInt(24);
-                f = NoteBlock.getPitchFromNote(i);
-                world.addParticle(ParticleTypes.NOTE, pos.getX() + 0.5, pos.getY() + 1.2, pos.getZ() + 0.5, i / 24.0, 0.0F, 0.0F);
-            } else {
-                f = 1.0F;
-            }
-        }
-
-        world.playSeededSound(null, pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, noteBlockInstrument.getSoundEvent(), SoundSource.RECORDS, 3.0F, f, world.random.nextLong());
-        return true;
-    }
-}

src/main/java/net/lerariemann/infinity/data/loot/InfinityBlockLootTableProvider.java

···
 		dropOther(ModBlocks.IRIDESCENT_KELP_PLANT.get(), Items.KELP);
 		createSlabItemTable(ModBlocks.NETHERITE_SLAB.get());
 		dropSelf(ModBlocks.NETHERITE_STAIRS.get());
-		dropSelf(ModBlocks.NOTES_BLOCK.get());
 	}
 }
 //?}

src/main/java/net/lerariemann/infinity/data/recipe/InfinityRecipeProvider.java

···
 		iridescence(CHROMATIC_MATTER, CHROMATIC_MATTER, "recipe_info.iridescence.infinity.chromatic_matter").save(output);
 		portal(AMETHYST_SHARD, TRANSFINITE_KEY.get(), "recipe_info.portal.infinity.attuned").save(output, "infinity:key_from_portal");
 		iridescence(TRANSFINITE_KEY, TRANSFINITE_KEY, "recipe_info.iridescence.infinity.key").save(output, "infinity:key_from_iridescence");
-		portal(NOTE_BLOCK, NOTES_BLOCK_ITEM.get()).save(output);
 		portal(TNT, TIME_BOMB_ITEM.get()).save(output, "infinity:timebomb_from_portal");
 		color(ItemTags.WOOL, CHROMATIC_WOOL).save(output, "infinity:chromatic_coloring_wool");
 		color(ItemTags.WOOL_CARPETS, CHROMATIC_CARPET).save(output, "infinity:chromatic_coloring_carpet");

src/main/java/net/lerariemann/infinity/mixin/options/NoteBlockMixin.java

···
 
 import net.lerariemann.infinity.options.InfinityOptions;
 import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
···
 import net.minecraft.world.level.block.state.BlockState;
 //? if >1.21.2 {
 import net.minecraft.world.level.redstone.Orientation;
+import net.minecraft.world.level.LevelReader;
 //?}
+import net.minecraft.world.level.LevelAccessor;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(NoteBlock.class)
 public abstract class NoteBlockMixin {
···
                 if (bl) {
                     playNote(null, state, level, pos);
                 }
-
-                level.setBlock(pos, state.setValue(NoteBlock.POWERED, bl), 0, 0);
-                ci.cancel();
+                level.setBlock(pos, state.setValue(NoteBlock.POWERED, bl), 18, 0);
             }
+            ci.cancel();
+        }
+    }
+
+    @Inject(method = "setInstrument", at = @At("HEAD"), cancellable = true)
+    //?if >1.21.2 {
+    void inj(LevelReader level, BlockPos pos, BlockState state, CallbackInfoReturnable<BlockState> cir) {
+    //?} else {
+    /*void inj(LevelAccessor level, BlockPos pos, BlockState state, CallbackInfoReturnable<BlockState> cir) {
+    *///?}
+        if (level instanceof ServerLevel world && InfinityOptions.access(world).isHaunted()) {
+            cir.setReturnValue(state);
         }
     }
 }

src/main/java/net/lerariemann/infinity/mixin/options/ServerWorldMixin.java

···
 
     @Inject(method = "tickChunk", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/material/FluidState;isRandomlyTicking()Z"))
     void inj(LevelChunk chunk, int randomTickSpeed, CallbackInfo ci, @Local BlockState bs, @Local BlockPos blockPos2, @Local FluidState fs) {
-        if (infinity$options.isHaunted() && random.nextInt(200) < (int)(Math.floor(getMoonBrightness() * 4))) {
-            updateNeighborsAt(blockPos2, bs.getBlock());
+        if (infinity$options.isHaunted() && random.nextInt(20) < (int)(Math.floor(getMoonBrightness() * 4))) {
+            Direction direction = Direction.values()[InfinityMod.random.nextInt(6)];
+            //? if <1.21.2 {
+            /*neighborUpdater.neighborChanged(blockPos2.relative(direction), bs.getBlock(), blockPos2);
+            *///?} else {
+            neighborUpdater.neighborChanged(blockPos2.relative(direction), bs.getBlock(), null);
+            //?}
         }
     }
 

src/main/java/net/lerariemann/infinity/registry/core/ModBlocks.java

···
             IridescentKelpBlock::new, (VersionMethods.copyBlockProperties(Blocks.KELP).mapColor(MapColor.COLOR_MAGENTA)));
     public static final RegistrySupplier<IridescentKelpBlock.Plant> IRIDESCENT_KELP_PLANT = register("iridescent_kelp_plant",
             IridescentKelpBlock.Plant::new, (VersionMethods.copyBlockProperties(Blocks.KELP).mapColor(MapColor.COLOR_MAGENTA)));
-    public static final RegistrySupplier<Block> NOTES_BLOCK = register("notes_block", 
-            NotesBlock::new, (VersionMethods.copyBlockProperties(Blocks.NOTE_BLOCK).randomTicks()));
     public static final RegistrySupplier<RailHelper> RAIL_HELPER = register("rail_helper",
             RailHelper::new, (BlockBehaviour.Properties.of().strength(-1.0F, 3600000.8F).mapColor(MapColor.NONE)
                     .noLootTable().noOcclusion().isValidSpawn((state, getter, pos, type)-> false).pushReaction(PushReaction.BLOCK)

src/main/java/net/lerariemann/infinity/registry/core/ModItems.java

···
             registerBlockItemAfter(ModBlocks.NETHERITE_SLAB, CreativeModeTabs.BUILDING_BLOCKS, Items.NETHERITE_BLOCK, BlockItem::new);
     public static final RegistrySupplier<Item> NETHERITE_STAIRS_ITEM =
             registerBlockItemAfter(ModBlocks.NETHERITE_STAIRS, CreativeModeTabs.BUILDING_BLOCKS, Items.NETHERITE_BLOCK, BlockItem::new);
-    public static final RegistrySupplier<Item> NOTES_BLOCK_ITEM =
-            registerBlockItemAfter(ModBlocks.NOTES_BLOCK, CreativeModeTabs.FUNCTIONAL_BLOCKS, Items.NOTE_BLOCK, BlockItem::new);
     public static final RegistrySupplier<Item> TIME_BOMB_ITEM =
             registerBlockItemAfter(ModBlocks.TIME_BOMB, CreativeModeTabs.FUNCTIONAL_BLOCKS, VAULT, BlockItem::new);
     public static final RegistrySupplier<Item> IRIDESCENT_WOOL  =

src/main/java/net/lerariemann/infinity/registry/var/ModItemGroups.java

···
             addAfter(event, LECTERN, ModItems.ALTAR_ITEM.get());
             addAfter(event, LODESTONE, ModItems.ANT_ITEM.get());
             addAfter(event, CHISELED_BOOKSHELF, ModItems.BOOK_BOX_ITEM.get());
-            addAfter(event, NOTE_BLOCK, ModItems.NOTES_BLOCK_ITEM.get());
             addAfter(event, VAULT, ModItems.TIME_BOMB_ITEM.get());
         } else if (equals(creativeModeTab, CreativeModeTabs.INGREDIENTS)) {
             addAfter(event, DISC_FRAGMENT_5, ModItems.FOOTPRINT.get());

src/main/java/net/lerariemann/infinity/registry/var/ModMaterialRules.java

···
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import dev.architectury.registry.registries.DeferredRegister;
+import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.iridescence.Iridescence;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.util.InfinityMethods;
···
 import net.minecraft.util.Mth;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.LadderBlock;
+import net.minecraft.world.level.block.NoteBlock;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.properties.BlockStateProperties;
 import net.minecraft.world.level.block.state.properties.Half;
+import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
 import net.minecraft.world.level.levelgen.SurfaceRules;
+import org.jetbrains.annotations.Nullable;
 
 //? if neoforge
 /*import javax.annotation.ParametersAreNonnullByDefault;*/
···
             @Override
             public SurfaceRules.SurfaceRule apply(SurfaceRules.Context materialRuleContext) {
                 return new RandomColoredBlock(str);
+            }
+        }
+    }
+
+    public static class Notes implements SurfaceRules.SurfaceRule {
+        @Override
+        public @Nullable BlockState tryApply(int i, int j, int k) {
+            NoteBlockInstrument instr = InfinityMethods.getRandomInstrument();
+            BlockState bs = Blocks.NOTE_BLOCK.defaultBlockState().setValue(NoteBlock.INSTRUMENT, instr);
+            if (instr.isTunable()) bs = bs.setValue(NoteBlock.NOTE, InfinityMod.random.nextInt(24));
+            return bs;
+        }
+
+        enum Rule implements SurfaceRules.RuleSource {
+            INSTANCE;
+            static final KeyDispatchDataCodec<Rule> CODEC = KeyDispatchDataCodec.of(MapCodec.unit(INSTANCE));
+            @Override
+            public KeyDispatchDataCodec<? extends SurfaceRules.RuleSource> codec() {
+                return CODEC;
+            }
+            @Override
+            public SurfaceRules.SurfaceRule apply(SurfaceRules.Context materialRuleContext) {
+                return new Notes();
             }
         }
     }
···
     public static void registerRules() {
         register("chaos", RandomBlockMaterialRule.CODEC);
         register("colored_chaos", RandomColoredBlock.Rule.CODEC);
+        register("notes", Notes.Rule.CODEC);
         register("library", Library.Rule.CODEC);
         register("backrooms", Backrooms.Rule.CODEC);
         register("nexus", Nexus.Rule.CODEC);

src/main/java/net/lerariemann/infinity/util/InfinityMethods.java

···
 import net.minecraft.world.level.biome.Biome;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
 import net.minecraft.world.level.levelgen.LegacyRandomSource;
 import net.minecraft.world.level.levelgen.synth.NormalNoise;
 //? if <1.21 {
···
         } while (false);
 
         return 1.0;
+    }
+
+    static NoteBlockInstrument getRandomInstrument() {
+        NoteBlockInstrument[] instruments = NoteBlockInstrument.values();
+        return instruments[InfinityMod.random.nextInt(instruments.length-7)];
     }
 }

src/main/resources/config/common/easter/notes.json

···
 {
-  "infinity_version": 2006000,
+  "infinity_version": 2006003,
   "options": {
-    "haunted": true
+    "haunted": true,
+    "solar_texture": "textures/block/redstone_lamp_on.png",
+    "moons": [
+      {
+        "lunar_texture": "textures/block/note_block.png"
+      }
+    ]
   },
   "generator": {
-    "type": "minecraft:flat",
+    "type": "minecraft:noise",
     "settings": {
-      "biome": "minecraft:the_void",
-      "lakes": false,
-      "features": false,
-      "layers": [
-        {
-          "height": 1,
-          "block": "minecraft:note_block"
-        }
-      ]
+      "sea_level": 0,
+      "disable_mob_generation": false,
+      "ore_veins_enabled": false,
+      "aquifers_enabled": false,
+      "legacy_random_source": false,
+      "default_block": {
+        "Name": "minecraft:black_concrete"
+      },
+      "default_fluid": {
+        "Name": "minecraft:water"
+      },
+      "spawn_target": [],
+      "noise": {
+        "min_y": 0,
+        "height": 256,
+        "size_horizontal": 2,
+        "size_vertical": 2
+      },
+      "noise_router": {
+        "vein_ridged": "infinity:vein_ridged",
+        "fluid_level_spread": 0.0,
+        "vegetation": "infinity:vegetation",
+        "vein_gap": "infinity:vein_gap",
+        "continents": "minecraft:overworld/continents",
+        "initial_density_without_jaggedness": {
+          "to_y": 6,
+          "from_value": 1.0,
+          "to_value": -1.0,
+          "from_y": 0,
+          "type": "minecraft:y_clamped_gradient"
+        },
+        "lava": 0.0,
+        "barrier": 0.0,
+        "depth": {
+          "from_value": 1.5,
+          "to_y": 256,
+          "to_value": -1.5,
+          "type": "minecraft:y_clamped_gradient",
+          "from_y": 0
+        },
+        "ridges": "minecraft:overworld/ridges",
+        "erosion": "minecraft:overworld/erosion",
+        "temperature": "infinity:temperature",
+        "final_density": {
+          "to_y": 6,
+          "from_value": 1.0,
+          "to_value": -1.0,
+          "from_y": 0,
+          "type": "minecraft:y_clamped_gradient"
+        },
+        "vein_toggle": "infinity:vein_toggle",
+        "fluid_level_floodedness": 0.0
+      },
+      "surface_rule": {
+        "type": "minecraft:sequence",
+        "sequence": [
+          {
+            "type": "minecraft:condition",
+            "if_true": {
+              "type": "minecraft:not",
+              "invert": {
+                "type": "y_above",
+                "anchor": {
+                  "absolute": 1
+                },
+                "surface_depth_multiplier": 0,
+                "add_stone_depth": false
+              }
+            },
+            "then_run": {
+              "type": "minecraft:block",
+              "result_state": {
+                "Name": "minecraft:bedrock"
+              }
+            }
+          },
+          {
+            "type": "minecraft:condition",
+            "if_true": {
+              "type": "minecraft:not",
+              "invert": {
+                "type": "y_above",
+                "anchor": {
+                  "absolute": 2
+                },
+                "surface_depth_multiplier": 0,
+                "add_stone_depth": false
+              }
+            },
+            "then_run": {
+              "type": "minecraft:block",
+              "result_state": {
+                "Name": "minecraft:stone"
+              }
+            }
+          },
+          {
+            "type": "infinity:notes"
+          }
+        ]
+      }
+    },
+    "biome_source": {
+      "type": "fixed",
+      "biome": "minecraft:the_void"
     }
   }
 }