[1.20.4] tutorial guide working example for creating Level capability ??

[perromercenary00]

 

im stuck in a problem whit BlockEntities i cannot solve
so im trying to work around it but in the less complex way possible 

i think is posible to store data to the minecraft world 

in older versions people talk about  WordDataSave i dont find anything about it for 1.20.4 

i find a tutorial for player capability in 1.19 

  Reveal hidden contents

https://github.com/Tutorials-By-Kaupenjoe/Forge-Tutorial-1.19/commit/d82cd961b4e38634780edf778abfa0daa8288e18#diff-3cade16c2ef664bd98eb5136c3e813656033d59500e09c72a93bdd8b1c21f902

 

here is an event 

	
    //########## ########## ########## ##########
    @SubscribeEvent
    public static void onAttachCapabilitiesPlayer(AttachCapabilitiesEvent<Entity> event) {
        if(event.getObject() instanceof Player) {
            if(!event.getObject().getCapability(PlayerThirstProvider.PLAYER_THIRST).isPresent()) {
                event.addCapability(new ResourceLocation(mercmod.MOD_ID, "properties"), new PlayerThirstProvider());
            }
        }
    }
	

 soo i made this 

    //########## ########## ########## ##########
    @SubscribeEvent
    public static void onAttachCapabilitiesLevel(AttachCapabilitiesEvent<Level> event) {

    }

i think i can do some witchcraft  here  but is many things don't understand 
to start whit i dont get yet how to recall the saved data from a BlockEntity 

the handler still in progress the plan is to make a Map to store nbt data using the block coordinates as index

later store that map as a big nbt 

  Reveal hidden contents

				
			package mercmod.capabity;				
			import net.minecraft.core.BlockPos;
		import net.minecraft.nbt.CompoundTag;
		import net.minecraft.world.item.ItemStack;
		import net.minecraft.world.level.Level;
		import net.minecraft.world.level.block.state.CompoundTag;
		import net.minecraftforge.common.capabilities.AutoRegisterCapability;
		import org.checkerframework.checker.units.qual.A;				
			import java.nio.charset.StandardCharsets;
		import java.util.*;
		import java.util.stream.Collectors;				
			@AutoRegisterCapability
		public class warudo_handler {				
			    public Level warudo;
		    // X Z Y
		    private Map<Integer, Map<Integer, Map<Integer, CompoundTag>>> map = new HashMap<Integer, Map<Integer, Map<Integer, CompoundTag>>>();
		    // Z Y
		    private Map<Integer, Map<Integer, CompoundTag>> X = new HashMap<Integer, Map<Integer, CompoundTag>>();
		    // Y
		    private Map<Integer, CompoundTag> Z = new HashMap<Integer, CompoundTag>();    
		    				
			    private List<Integer> color = new ArrayList<>();
		    private List<BlockPos> pos = new ArrayList<>();				
			
		    public warudo_handler(Level warudo)
		    {
		        //super(9);
		        this.warudo  = warudo;
		    }				
			
		    // ########## ########## ########## ##########
		    // sets the blockstate for this blockpos in the blockmap
		    public boolean setBlock(BlockPos pos, CompoundTag value, int mode) {
		        return setCompoundTag(pos.getX(), pos.getY(), pos.getZ(), value);
		    }				
			    public boolean setCompoundTag(BlockPos pos, CompoundTag value) {
		        return setCompoundTag(pos.getX(), pos.getY(), pos.getZ(), value);
		    }				
			    public boolean setCompoundTag(int bx, int by, int bz, CompoundTag value) {				
			        X = map.get(bx);				
			        if (X == null) {
		            X = new HashMap<Integer, Map<Integer, CompoundTag>>();
		            map.put(bx, X);
		        }				
			        if (X != null) {
		            Z = X.get(bz);				
			            if (Z == null) {
		                Z = new HashMap<Integer, CompoundTag>();
		                X.put(bz, Z);
		            }				
			            if (Z != null) {
		                Z.put(by, value);				
			                this.block_list.add(new BlockPos(bx, by, bz));
		                return true;
		            }
		        }				
			        return false;
		    }				
			    // ########## ########## ########## ##########
		    // return the blockstate if alredy exist in BlockMap
		    // if not exist reads the CompoundTag from the world
		    public CompoundTag getCompoundTag(BlockPos pos) {
		        CompoundTag nbt = getCompoundTag(pos.getX(), pos.getY(), pos.getZ());
		        return nbt;
		    }				
			    public CompoundTag getCompoundTag(int bx, int by, int bz) {
		        CompoundTag nbt = null;				
			        X = map.get(bx);				
			        if (X != null) {
		            Z = X.get(bz);				
			            if (Z != null) {
		                nbt = Z.get(by);				
			                if (nbt != null) {
		                    return nbt;
		                }
		            }
		        }				
			        nbt = this.warudo.getCompoundTag(new BlockPos(bx, by, bz));
		        return nbt;
		    }				
			    // ########## ########## ########## ##########
		    // return the blockstate if alredy exist in BlockMap
		    // if not exist in the BlockMap return null
		    public CompoundTag hasCompoundTag(BlockPos pos) {
		        CompoundTag nbt = hasCompoundTag(pos.getX(), pos.getY(), pos.getZ());
		        return nbt;
		    }				
			    public CompoundTag hasCompoundTag(int bx, int by, int bz) {
		        CompoundTag nbt = null;				
			        X = map.get(bx);				
			        if (X != null) {
		            Z = X.get(bz);				
			            if (X != null) {
		                nbt = Z.get(by);
		            }
		        }				
			        return nbt;
		    }				
			    
		    
		    
		    
		    
		    				
			    public void saveNBTData(CompoundTag nbt) {
		        String[] stringArray = pos.stream()
		                .map(BlockPos::toShortString)
		                .toArray(String[]::new);
		        String concatenatedString = String.join(";", stringArray);
		        byte[] byteArray = concatenatedString.getBytes(StandardCharsets.UTF_8);
		        nbt.putByteArray("pos", byteArray);
		        nbt.putIntArray("color", color);
		    }				
			    public void loadNBTData(CompoundTag nbt) {
		        byte[] byteArray = nbt.getByteArray("pos");
		        String restoredString = new String(byteArray, StandardCharsets.UTF_8);
		        String[] restoredArray = restoredString.split(";");				
			        pos = Arrays.stream(restoredArray).map(s -> {
		            String[] parts = s.split(",");
		            return new BlockPos(Integer.valueOf(parts[0]), Integer.valueOf(parts[1]), Integer.valueOf(parts[2]));
		        }).collect(Collectors.toList());
		        color = Arrays.stream(nbt.getIntArray("color"))
		                .boxed()
		                .collect(Collectors.toList());
		    }
		}				
			

 

 

##########

any way the question is if theres alredy a tutorial for 1.20.4 for this ??

or some alredy working code from someone else doing something similar ?