Merge pull request #11 from integr-dev/develop

HOTFIX: Removed broken legacy syntax

Author: integr-dev

README.md

@@ -164,29 +164,6 @@ fun greet() {
 }
 ```
 
-
-#### Script Syntax: Classic and Modern
-
-Backbone supports two ways to write scripts:
-
-- **Modern DSL (Recommended):** The new `lifecycle { ... }` syntax is concise, declarative, and covers most use cases for event handling, lifecycle hooks, and inter-script communication. All examples in this README use the new DSL.
-- **Classic API (Still Supported):** The old style, where you inherit from `ManagedLifecycle` and override `onLoad`/`onUnload`, is still fully supported. This approach is more flexible and powerful for advanced users, as it allows you to write imperative code and manage the lifecycle yourself. You can mix and match both styles as needed.
-
-Example of the classic style:
-
-```kotlin
-class MyScript : ManagedLifecycle() {
-    override fun onLoad() {
-        // Custom initialization logic
-    }
-    override fun onUnload() {
-        // Cleanup logic
-    }
-}
-```
-
-For most scripts, the new DSL is recommended for its simplicity, but the classic approach remains available for complex or non-declarative scenarios.
-
 ### Storage and Configuration
 
 Backbone provides a simple and powerful way to manage your plugin's data and configuration through `ResourcePool`s. This system allows you to easily handle databases and configuration files in a structured manner.

build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "net.integr"
-version = "1.6.0"
+version = "1.6.1"
 
 repositories {
     mavenCentral()

src/main/kotlin/net/integr/backbone/systems/hotloader/GlobalScriptFunctions.kt

@@ -14,11 +14,18 @@
 package net.integr.backbone.systems.hotloader
 
 import net.integr.backbone.Backbone
+import net.integr.backbone.systems.event.BackboneEventHandler
 import net.integr.backbone.systems.hotloader.isc.InterScriptDuckTypedEvent
 import net.integr.backbone.systems.hotloader.isc.IscMap
 import net.integr.backbone.systems.hotloader.isc.IscMapBuilder
+import net.integr.backbone.systems.hotloader.lifecycle.LifecycleSustainedState
 import net.integr.backbone.systems.hotloader.lifecycle.ManagedLifecycle
+import net.integr.backbone.systems.hotloader.lifecycle.sustained
+import net.integr.backbone.systems.text.component
+import java.awt.Color
+import kotlin.inc
 import kotlin.reflect.full.starProjectedType
+import kotlin.toString
 
 /**
  * DSL entrypoint for defining a script lifecycle.

src/main/kotlin/net/integr/backbone/systems/hotloader/lifecycle/LifecycleSustainedState.kt

@@ -28,15 +28,14 @@ import kotlin.reflect.KProperty
  * @property value The current value of the state.
  * @since 1.0.0
  */
-class LifecycleSustainedState<T>(private var value: T) : ReadWriteProperty<ManagedLifecycle, T> {
+class LifecycleSustainedState<T>(private var value: T) : ReadWriteProperty<Nothing?, T> {
     /**
-     * The unique identifier for this sustained state.
-     * This is typically the name of the property it's delegated to.
+     * The unique identifier for this sustained state. This is assigned counting up from 0 for each `ManagedLifecycle` instance, based on the order of declaration.
      *
      * @since 1.0.0
      */
-    var id: String? = null
-        private set
+    var id: Int? = null
+        internal set
 
     /**
      * The default value of the state.
@@ -53,7 +52,7 @@ class LifecycleSustainedState<T>(private var value: T) : ReadWriteProperty<Manag
      * @return The current value of the state.
      * @since 1.0.0
      */
-    override fun getValue(thisRef: ManagedLifecycle, property: KProperty<*>): T {
+    override fun getValue(thisRef: Nothing?, property: KProperty<*>): T {
         return value
     }
 
@@ -65,28 +64,10 @@ class LifecycleSustainedState<T>(private var value: T) : ReadWriteProperty<Manag
      * @param value The new value to set.
      * @since 1.0.0
      */
-    override fun setValue(thisRef: ManagedLifecycle, property: KProperty<*>, value: T) {
+    override fun setValue(thisRef: Nothing?, property: KProperty<*>, value: T) {
         this.value = value
     }
 
-    /**
-     * Creates a [LifecycleSustainedState] instance and registers it with the [ManagedLifecycle] instance.
-     *
-     * This operator is called automatically when a `LifecycleSustainedState` is declared as a property
-     * within a `ManagedLifecycle` class. It assigns an ID to the state based on the property name
-     * and adds the state to the `ManagedLifecycle`'s tracking mechanism.
-     *
-     * @param thisRef The [ManagedLifecycle] instance that owns this property.
-     * @param property The [KProperty] representing this state property.
-     * @return This [ReadWriteProperty] instance.
-     * @since 1.0.0
-     */
-    operator fun provideDelegate(thisRef: ManagedLifecycle, property: KProperty<*>): ReadWriteProperty<ManagedLifecycle, T> {
-        id = property.name
-        thisRef.trackState(this)
-        return this
-    }
-
     /**
      * Sets the state of this property to the given value without type checking.
      * This method is intended for internal use by the hotloader to restore state after a reload.

src/main/kotlin/net/integr/backbone/systems/hotloader/lifecycle/ManagedLifecycle.kt

@@ -29,6 +29,8 @@ import org.jetbrains.annotations.ApiStatus
  */
 abstract class ManagedLifecycle : Listener {
     private var sustainedStates: Set<LifecycleSustainedState<*>> = mutableSetOf()
+    private var sustainedNextId = 0
+
 
     /**
      * Called when the component is loaded.
@@ -69,6 +71,24 @@ abstract class ManagedLifecycle : Listener {
         onUnload()
     }
 
+    /**
+     * Creates a new [LifecycleSustainedState] with the given initial value and tracks it for state persistence.
+     *
+     * This method should be used within `ManagedLifecycle` classes to create sustained state properties.
+     * The returned `LifecycleSustainedState` can be delegated to a property to enable state persistence across reloads.
+     *
+     * @param T The type of the value being sustained.
+     * @param value The initial value of the sustained state.
+     * @return A new `LifecycleSustainedState` instance initialized with the given value.
+     * @since 1.6.0
+     */
+    fun <T> sustained(value: T): LifecycleSustainedState<T> {
+        val s = LifecycleSustainedState(value)
+        s.id = sustainedNextId++
+        trackState(s)
+        return s
+    }
+
     /**
      * Add a [LifecycleSustainedState] to be tracked by this [ManagedLifecycle] instance.
      *