0) NetworkHandler.java

package matteroverdrive.core.packet;

import java.util.Optional;

import matteroverdrive.References;
import matteroverdrive.core.packet.type.clientbound.PacketClientMNData;
import matteroverdrive.core.packet.type.clientbound.PacketClientMatterValues;
import matteroverdrive.core.packet.type.clientbound.PacketPlayMatterScannerSound;
import matteroverdrive.core.packet.type.clientbound.PacketSyncClientEntityCapability;
import matteroverdrive.core.packet.type.clientbound.PacketUpdateTile;
import matteroverdrive.core.packet.type.serverbound.PacketCancelReplication;
import matteroverdrive.core.packet.type.serverbound.PacketQueueReplication;
import matteroverdrive.core.packet.type.serverbound.PacketToggleMatterScanner;
import matteroverdrive.core.packet.type.serverbound.PacketUpdateCapabilitySides;
import matteroverdrive.core.packet.type.serverbound.PacketUpdateRedstoneMode;
import matteroverdrive.core.packet.type.serverbound.PacketUpdateTransporterLocationInfo;
import matteroverdrive.core.property.message.*;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Entity;
import net.minecraftforge.network.NetworkDirection;
import net.minecraftforge.network.NetworkRegistry;
import net.minecraftforge.network.PacketDistributor;
import net.minecraftforge.network.simple.SimpleChannel;

public class NetworkHandler {

	private static final String PROTOCOL_VERSION = "1";
	private static int disc = 0;
	public static final SimpleChannel CHANNEL = NetworkRegistry.newSimpleChannel(
			new ResourceLocation(References.ID, "main"), () -> PROTOCOL_VERSION, PROTOCOL_VERSION::equals,
			PROTOCOL_VERSION::equals);

	public static void init() {
		
		/* SERVER-BOUND */
		
		CHANNEL.registerMessage(disc++, PacketUpdateRedstoneMode.class, PacketUpdateRedstoneMode::encode,
				PacketUpdateRedstoneMode::decode, PacketUpdateRedstoneMode::handle,
				Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, PacketUpdateCapabilitySides.class, PacketUpdateCapabilitySides::encode,
				PacketUpdateCapabilitySides::decode, PacketUpdateCapabilitySides::handle,
				Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, PacketUpdateTransporterLocationInfo.class,
				PacketUpdateTransporterLocationInfo::encode, PacketUpdateTransporterLocationInfo::decode,
				PacketUpdateTransporterLocationInfo::handle, Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, PacketToggleMatterScanner.class, PacketToggleMatterScanner::encode,
				PacketToggleMatterScanner::decode, PacketToggleMatterScanner::handle,
				Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, PacketQueueReplication.class, PacketQueueReplication::encode,
				PacketQueueReplication::decode, PacketQueueReplication::handle,
				Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, PacketCancelReplication.class, PacketCancelReplication::encode,
				PacketCancelReplication::decode, PacketCancelReplication::handle,
				Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, UpdateServerContainerPropertyMessage.class, UpdateServerContainerPropertyMessage::encode,
						UpdateServerContainerPropertyMessage::decode, UpdateServerContainerPropertyMessage::consume,
						Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, UpdateServerEntityPropertyMessage.class, UpdateServerEntityPropertyMessage::encode,
						UpdateServerEntityPropertyMessage::decode, UpdateServerEntityPropertyMessage::consume,
						Optional.of(NetworkDirection.PLAY_TO_SERVER));
		CHANNEL.registerMessage(disc++, UpdateServerBlockEntityPropertyMessage.class, UpdateServerBlockEntityPropertyMessage::encode,
						UpdateServerBlockEntityPropertyMessage::decode, UpdateServerBlockEntityPropertyMessage::consume,
						Optional.of(NetworkDirection.PLAY_TO_SERVER));
		
		/* CLIENT-BOUND */
		
		CHANNEL.registerMessage(disc++, PacketUpdateTile.class, PacketUpdateTile::encode, PacketUpdateTile::decode,
				PacketUpdateTile::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, PacketClientMatterValues.class, PacketClientMatterValues::encode,
				PacketClientMatterValues::decode, PacketClientMatterValues::handle,
				Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, PacketSyncClientEntityCapability.class,
				PacketSyncClientEntityCapability::encode, PacketSyncClientEntityCapability::decode,
				PacketSyncClientEntityCapability::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, PacketClientMNData.class,
				PacketClientMNData::encode, PacketClientMNData::decode,
				PacketClientMNData::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, PacketPlayMatterScannerSound.class,
				PacketPlayMatterScannerSound::encode, PacketPlayMatterScannerSound::decode,
				PacketPlayMatterScannerSound::handle, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, UpdateClientContainerPropertyMessage.class,
						UpdateClientContainerPropertyMessage::encode, UpdateClientContainerPropertyMessage::decode,
						UpdateClientContainerPropertyMessage::consume, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, UpdateClientEntityPropertyMessage.class,
						UpdateClientEntityPropertyMessage::encode, UpdateClientEntityPropertyMessage::decode,
						UpdateClientEntityPropertyMessage::consume, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
		CHANNEL.registerMessage(disc++, UpdateClientBlockEntityPropertyMessage.class,
						UpdateClientBlockEntityPropertyMessage::encode, UpdateClientBlockEntityPropertyMessage::decode,
						UpdateClientBlockEntityPropertyMessage::consume, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
	}

	public static void sendUpdateClientContainerProperties(ServerPlayer player, UpdateClientContainerPropertyMessage message) {
		CHANNEL.send(PacketDistributor.PLAYER.with(() -> player), message);
	}

	public static void sendUpdateServerContainerProperties(UpdateServerContainerPropertyMessage message) {
		CHANNEL.send(PacketDistributor.SERVER.noArg(), message);
	}

	public static void sendUpdateClientEntityProperties(Entity entity, UpdateClientEntityPropertyMessage message) {
		CHANNEL.send(PacketDistributor.TRACKING_ENTITY.with(() -> entity), message);
	}

	public static void sendUpdateServerEntityProperties(UpdateServerEntityPropertyMessage message) {
		CHANNEL.send(PacketDistributor.TRACKING_ENTITY.noArg(), message);
	}

	public static void sendUpdateClientBlockEntityProperties(ServerPlayer player, UpdateClientBlockEntityPropertyMessage message) {
		CHANNEL.send(PacketDistributor.PLAYER.with(() -> player), message);
	}

	public static void sendUpdateServerBlockEntityProperties(UpdateServerBlockEntityPropertyMessage message) {
		CHANNEL.send(PacketDistributor.PLAYER.noArg(), message);
	}

}

1) Added Field, and sendUpdate in setChanged GenericTile.java

package matteroverdrive.core.tile;

import java.util.ArrayList;
import java.util.List;

import matteroverdrive.References;
import matteroverdrive.common.item.ItemUpgrade;
import matteroverdrive.core.capability.IOverdriveCapability;
import matteroverdrive.core.capability.types.CapabilityType;
import matteroverdrive.core.capability.types.item.CapabilityInventory;
import matteroverdrive.core.property.IPropertyManaged;
import matteroverdrive.core.property.Property;
import matteroverdrive.core.property.PropertyManager;
import matteroverdrive.core.property.manager.BlockEntityPropertyManager;
import matteroverdrive.core.tile.utils.ITickableTile;
import matteroverdrive.core.tile.utils.IUpdatableTile;
import matteroverdrive.core.utils.UtilsCapability;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.protocol.game.ClientGamePacketListener;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.Nameable;
import net.minecraft.world.inventory.SimpleContainerData;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
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.block.state.properties.BlockStateProperties;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.common.util.TriPredicate;
import org.jetbrains.annotations.Nullable;

public abstract class GenericTile extends BlockEntity implements Nameable, ITickableTile, IUpdatableTile, IPropertyManaged {

	private List<IOverdriveCapability> capabilities = new ArrayList<>();

	public boolean hasMenu = false;
	private MenuProvider menu;

	public boolean isTickable = false;
	
	public boolean hasMenuData = false;
	public boolean hasRenderData = false;
	
	protected long ticks = 0;

	protected final BlockEntityPropertyManager propertyManager;

	protected GenericTile(BlockEntityType<?> type, BlockPos pos, BlockState state) {
		super(type, pos, state);
		this.propertyManager = new BlockEntityPropertyManager(pos);
	}

	public void setMenuProvider(MenuProvider menu) {
		hasMenu = true;
		this.menu = menu;
	}

	public MenuProvider getMenuProvider() {
		return menu;
	}

	public void setTickable() {
		isTickable = true;
	}
	
	public void setHasMenuData() {
		hasMenuData = true;
	}
	
	public void setHasRenderData() {
		hasRenderData = true;
	}

	@Override
	public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
		for (IOverdriveCapability i : capabilities) {
			if (i.matchesCapability(cap)) {
				return i.getCapability(cap, side);
			}
		}
		return super.getCapability(cap, side);
	}

	public void addCapability(IOverdriveCapability cap) {
		boolean valid = true;
		for (IOverdriveCapability i : capabilities) {
			if (i.getCapabilityType() == cap.getCapabilityType()) {
				valid = false;
				break;
			}
		}
		if (!valid) {
			throw new RuntimeException("error: capability type " + cap.getCapabilityType() + " already added");
		}
		capabilities.add(cap);
	}

	public boolean hasCapability(CapabilityType type) {
		for (IOverdriveCapability cap : capabilities) {
			if (cap.getCapabilityType() == type) {
				return true;
			}
		}
		return false;
	}

	public <T extends IOverdriveCapability> T exposeCapability(CapabilityType type) {
		for (IOverdriveCapability cap : capabilities) {
			if (cap.getCapabilityType() == type) {
				return (T) cap;
			}
		}
		return null;
	}

	@Override
	public void onLoad() {
		super.onLoad();
		for (IOverdriveCapability cap : capabilities) {
			cap.onLoad(this);
		}
	}

	public void refreshCapabilities() {
		for (IOverdriveCapability cap : capabilities) {
			cap.refreshCapability();
		}
	}

	@Override
	public void setRemoved() {
		super.setRemoved();
		for (IOverdriveCapability cap : capabilities) {
			cap.invalidateCapability();
		}
	}

	@Override
	protected void saveAdditional(CompoundTag tag) {
		super.saveAdditional(tag);
		for (IOverdriveCapability cap : capabilities) {
			tag.put(cap.getSaveKey(), cap.serializeNBT());
		}
	}

	@Override
	public void load(CompoundTag tag) {
		super.load(tag);
		for (IOverdriveCapability cap : capabilities) {
			cap.deserializeNBT(tag.getCompound(cap.getSaveKey()));
		}
	}

	@Override
	public void setChanged() {
		super.setChanged();
		this.propertyManager.sendBlockEntityChanges(this.getBlockPos());
	}

	public MutableComponent getContainerName(String name) {
		return Component.translatable("container." + name);
	}

	public Direction getFacing() {
		Level world = getLevel();
		BlockState state = world.getBlockState(getBlockPos());
		if (state.hasProperty(BlockStateProperties.FACING)) {
			return state.getValue(BlockStateProperties.FACING);
		}

		return Direction.UP;
	}

	public SimpleContainerData getCoordsData() {
		SimpleContainerData array = new SimpleContainerData(3);
		array.set(0, worldPosition.getX());
		array.set(1, worldPosition.getY());
		array.set(2, worldPosition.getZ());
		return array;
	}

	@Override
	// TODO allow translations
	public Component getName() {
		return Component.literal(References.ID + ".default.tile.name");
	}

	protected static TriPredicate<Integer, ItemStack, CapabilityInventory> machineValidator() {
		return (x, y, i) -> x < i.outputIndex()
				|| x >= i.energySlotsIndex() && x < i.matterSlotsIndex() && UtilsCapability.hasEnergyCap(y)
				|| x >= i.matterSlotsIndex() && x < i.upgradeIndex() && UtilsCapability.hasMatterCap(y)
				|| x >= i.upgradeIndex() && y.getItem() instanceof ItemUpgrade upgrade
						&& i.isUpgradeValid(upgrade.type);
	}
	
	@Override
	public long getTicks() {
		return ticks;
	}
	
	public void incrementTicks() {
		ticks++;
	};

	@Override
	public PropertyManager getPropertyManager() {
		return this.propertyManager;
	}
}