[MUI2] Fix client classes being loaded on server

dependencies.gradle

@@ -10,6 +10,10 @@ dependencies {
     // Configuration
     jarJar(modApi(forge.configuration.get()))
 
+    // Math Parser
+    jarJar(implementation(libs.mxparser.get()))
+    additionalRuntimeClasspath(libs.mxparser.get())
+
     // Mixin (& Extras)
     annotationProcessor(variantOf(libs.mixin) { classifier("processor") })
     compileOnly(annotationProcessor(forge.mixinExtras.common.get()))
@@ -119,4 +123,6 @@ dependencies {
     modExtraLocalRuntime(forge.ponder)
     modExtraLocalRuntime(variantOf(forge.create) { classifier("slim") })
     modExtraLocalRuntime(forge.flywheel.forge)
+
+    modLocalRuntime(forge.curios)
 }

docs/content/Development/Data-Sync-System/Annotations.md

@@ -0,0 +1,89 @@
+---
+title: "Annotations"
+---
+
+# Annotations
+The following annotations define the sync/save behaviour for an `ISyncManaged` object.
+
+### `@SaveField`
+
+The `@SaveField` annotation defines a field that should be saved to the server. `nbtKey` is optional, the key will default to the field name.
+```java
+@SaveField(nbtKey="nbtKeyToSaveTo")
+public int mySaveInt = 10;
+```
+
+### `@SyncToClient`
+
+The `@SyncToClient` annotation defines a field with a value that should be synced to clients.
+
+!!! warning 
+    Client sync fields **do not** automatically detect changes. When changing a client sync field, call `ISyncManaged.getSyncDataHolder().markClientSyncFieldDirty(FIELD_NAME)`
+```java
+@SaveField(nbtKey="nbtKeyToSaveTo")
+@SyncToClient
+public int mySaveAndSyncInt = 10;
+
+@SyncToClient
+@RerenderOnChanged
+public long mySyncRerenderLong = 10000L;
+
+public void serverTick() {
+    int newIntValue = getNewIntValue();
+    long newLongValue = getNewLongValue();
+    if (mySaveAndSyncInt != newIntValue) {
+        mySaveAndSyncInt = newIntValue;
+        getSyncDataHolder().markClientSyncFieldDirty("mySaveAndSyncInt");
+    }
+    if (mySyncRerenderLong != newLongValue) {
+        mySyncRerenderLong = newLongValue;
+        getSyncDataHolder().markClientSyncFieldDirty("mySyncRerenderLong");
+    }
+}
+```
+
+### `@ClientFieldChangeListener` and `@RerenderOnChanged`
+
+The `@ClientFieldChangeListener` annotation defines a method to be called on the client when a client sync field has changed value;
+
+Annotating a `@SyncToClient` field with `@RerenderOnChanged` will cause clients to rerender the block entity when this field changes.
+
+```java
+@SyncToClient
+@SaveField
+@RerenderOnChanged
+public boolean isWorkingEnabled = true;
+
+@ClientFieldChangeListener(fieldName="isWorkingEnabled")
+public void isWorkingChanged() {
+    setRenderState(getRenderState().setValue(GTMachineModelProperties.IS_WORKING_ENABLED, isWorkingEnabled));
+}
+```
+
+### `@FieldDataModifier` and `@CustomDataField`
+
+
+
+The `@FieldDataModifier`annotation defines custom processing to be performed on the NBT for a field, e.g. for compatibility reasons.
+
+The `@CustomDataField`annotation defines a field with a type too complex to be serialised using the normal system. Custom data fields must have exactly one load modifier and one data modifier.
+
+Field data modifiers on non-custom fields will be applied *after* standard serialisation/deserialisation, and will be called with an argument containing the current tag.
+
+```java
+@CustomDataField
+@SaveField
+public VeryComplexType myVeryComplexValue = new VeryComplexType();
+
+@FieldDataModifier(fieldName="myVeryComplexValue", target=FieldDataModifier.MODIFY_TARGET.LOAD_NBT)
+public void loadVeryComplexValue(CompoundTag tag) {
+    // Process tag here.
+    myVeryComplexValue = new VeryComplexType();
+}
+
+@FieldDataModifier(fieldName="myVeryComplexValue", target=FieldDataModifier.MODIFY_TARGET.SAVE_NBT)
+public CompoundTag saveVeryComplexValue(CompoundTag tag, boolean isSendingToClient) {
+    // Save data here.
+    return tag;
+}
+```

docs/content/Development/Data-Sync-System/Migrating-From-LDLib-SyncData.md

@@ -0,0 +1,27 @@
+---
+title: "Migrating from LDLib SyncData"
+---
+# Migrating from LDLib SyncData
+
+### General migration guidelines
+
+- Remove all `ManagedFieldHolder` fields.
+- Replace `FieldManagedStorage` fields with `SyncDataHolder` fields.
+- Replace `IEnhancedManaged` objects with `ISyncManaged`.
+- Replace `IAsyncAutoSyncBlockEntity`, `IAutoPersistBlockEntity`, `IAutoSyncBlockEntity` and `IManagedBlockEntity` by extending `ManagedSyncBlockEntity`.
+
+### Annotations
+
+!!! warning
+Client sync fields **do not** automatically detect changes. When changing a client sync field, call `ISyncManaged.syncDataHolder.markClientSyncFieldDirty(FIELD_NAME)`
+
+- `@DescSynced` -> `@SyncToClient`
+- `@RequireRerender` -> `@RerenderOnChanged`
+- `@Persisted` -> `@SaveField`
+- `@UpdateListener` -> `@ClientFieldChangeListener` on listener method.
+- `@DropSaved` - Removed, make machines implement `IDropSaveMachine` instead
+- `@ReadOnlyManaged` and `@LazyManaged` See usage docs for instructions on complex sync objects 
+
+### Other changes
+
+ - `saveCustomPersistedData` & `loadCustomPersistedData` methods: Use `@CustomDataModifier` & `@FieldDataModifier`

docs/content/Development/Data-Sync-System/Usage.md

@@ -0,0 +1,98 @@
+---
+title: "Usage"
+---
+
+## Usage
+
+### Registering classes with the sync system
+
+At the core of the system is the interface `ISyncManaged`, which represents a class that to be synchronised with the client or saved.
+All block entities which should be synchronised or saved must extend the abstract class `ManagedSyncBlockEntity`.
+
+!!! warning 
+  Block entities that inherit `ManagedSyncBlockEntity` must call `ManagedSyncBlockEntity::updateTick`***every tick*** within their ticker, or they will not be saved.
+
+```java
+class MySyncObject implements ISyncManaged {
+    // Any class that directly implements ISyncManaged must have the following:
+     @Getter
+     protected final SyncDataHolder syncDataHolder = new SyncDataHolder(this);
+
+
+    /**
+     * Function called when the SyncDataHolder requests a rerender
+     */
+    void scheduleRenderUpdate();
+
+    /**
+     * Function called to notify the server that this object has been updated and must be synced to clients
+     */
+    void markAsChanged();
+}
+```
+
+### Registering fields to be managed by the system
+See [Annotations](Annotations.md)
+
+### Type compatibility
+The following field types are supported by default:
+- Any class implementing `ISyncManaged`
+- Any class implementing `INBTSerializable<Tag>`
+- All primitive types
+- If `T`, `K` are supported types:
+   - `T[]`
+   - `Set<T>`
+   - `List<T>`,
+   - `Map<T, K>`
+- `String`
+- `ItemStack`
+- `FluidStack`
+- `UUID`
+- `BlockPos`
+- `CompoundTag`
+- `GTRecipe`
+- `GTRecipeType`
+- `MachineRenderState`
+- `Material`
+- `Component`
+
+### Adding support for additional types
+
+To add support for an additional type, call `ValueTransformers.registerClassTransformer(Class<?> cls, IValueTransformer<?> transformer)` or `ValueTransformers.registerInterfaceTransformer(Class<?> cls, IValueTransformer<?> transformer)`
+
+The `IValueTransformer<T>` interface defines how a value of type `T` should be serialised.
+
+```java
+public interface IValueTransformer<T> {
+
+    // If this type cannot be instanced purely from a serialised tag.
+    // All complex type typically have mustProvideObject true 
+    default boolean mustProvideObject() {
+        return false;
+    }
+
+    // A method for serialising a value into a tag
+    // Called when serialising a value to be sent to the client
+    default Tag serializeClientSyncNBT(@Nullable T value, ISyncManaged holder) {
+      return serializeNBT(value, holder);
+    }
+
+    // A method for deserialising a value from a tag
+    // Called when deserialising a value on the client.
+    // If mustProvideObject == true, currentVal is the currently saved value.
+  default T deserializeClientNBT(Tag tag, ISyncManaged holder, @Nullable T currentVal) {
+      return deserializeNBT(tag, holder, currentVal);
+    }
+
+
+  // A method for serialising a value into a tag.
+  // The holder param is the object this sync value is attached to
+  Tag serializeNBT(T value, ISyncManaged holder);
+
+  // A method for deserialising a value from a tag
+  // If mustProvideObject == true, currentVal is the currently saved value.
+  T deserializeNBT(Tag tag, ISyncManaged holder, @Nullable T currentVal);
+}
+```
+
+Some types may be too complex to be processed using this system. For more complex NBT interactions, use the `@FieldDataModifier` and `@CustomDataField` annotations.

docs/content/Development/Data-Sync-System/index.md

@@ -0,0 +1,12 @@
+---
+title: "Data Sync/Save system "
+---
+
+# Data Sync/Save System
+
+For serialising data to saves and synchronising with clients, a custom data sync system based on Java Annotations is used.
+
+- See [Usage](Usage.md) for a guide on using the system
+- See [Annotations](Annotations.md) for a list of annotations provided by the system
+- See [Migrating From LDLib SyncData](Migrating-From-LDLib-SyncData.md) for instructions on how to migrate from the LDLib SyncData system, which was used in versions 7.x and lower.
+