Version 1.4.1

Author: EssentialGGBot

build-logic/build.gradle.kts

@@ -38,6 +38,8 @@ dependencies {
     implementation ("com.google.guava:guava:30.1.1-jre")
 
     implementation("gg.essential:essential-gradle-toolkit:0.7.1")
+    // TODO remove once EGT is updated
+    implementation("com.github.replaymod:preprocessor:221276c7d!!")
     // TODO remove once preprocessor+EGT are updated
     implementation("com.github.replaymod:remap:651e2e0a2!!") {
         exclude("org.jetbrains.kotlin", "kotlin-compiler-embeddable")

build-logic/src/main/kotlin/essential/preprocessor.kt

@@ -20,8 +20,8 @@ fun Project.configurePreprocessTree(versions: File) {
     configure<RootPreprocessExtension> {
         strictExtraMappings.set(true)
 
-        val fabric260200 = createNode("26.2-fabric", 260200, "mojang")
-        val fabric260100 = createNode("26.1-fabric", 260100, "mojang")
+        val fabric260200 = createNode("26.2-fabric", 260200, null)
+        val fabric260100 = createNode("26.1-fabric", 260100, null)
         val fabric12111 = createNode("1.21.11-fabric", 12111, "yarn")
         val fabric12109 = createNode("1.21.9-fabric", 12109, "yarn")
         val neoForge12107 = createNode("1.21.7-neoforge", 12107, "srg")

build-logic/src/main/kotlin/gg/essential/gradle/util/KotlinVersion.kt

@@ -21,6 +21,7 @@ data class KotlinVersion(
     val serialization: String,
 ) {
     companion object {
+        // Note: When updating stdlib version, also update the check at the start of IntegrationTestBootstrap.initialize
         val latest = KotlinVersion(null, "2.3.0", "1.10.2", "1.9.0")
 
         val fabricLanguageKotlin = latest.copy(mod = "1.13.8")

changelog/release-1.4.1.md

@@ -0,0 +1,12 @@
+Title: Appear offline
+Summary: Hide your online status
+
+## Appear offline
+Hide your online status from your friends. When enabled, your activity status is hidden and you'll appear offline. Perfect for when you just want to be left alone.
+- You can enable this via the "Appear offline" toggle in the Friends tab of the Essential Settings menu
+
+## Other Improvements
+- Added a "Friends" tab to the Essential settings. Here you can manage social settings like activity sharing, friend requests, and Essential chat
+
+## Bug Fixes
+- Fixed editing screenshots which caused all entities, particles, and/or terrain to become invisible on certain Minecraft versions

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/impl/basic/impl.kt

@@ -36,11 +36,15 @@ import kotlin.collections.asSequence
  * Unlike [gg.essential.gui.elementa.state.v2.impl.minimal.MarkThenPullImpl], this means that sub-graphs which are
  * potentially affected but whose dependencies have not actually changed, will not be visited (more than once per
  * them actually changing; as opposed to having to re-visit every time they are potentially affected).
- * That does mean that this implementation will in exchange potentially visit intermediate nodes which do not actually
- * have any effects attached to them any more (hence it only being "semi lazy").
+ * That does mean that this implementation will in exchange potentially visit intermediate nodes which, by the time
+ * they're being visited, do not actually have any effects attached to them any more (hence it only being "semi lazy").
  * However, in practice, non-affected nodes usually vastly outnumber dead intermediate nodes (especially because
  * those are usually garbage collected together with the respective effects that used them) by one to two orders of
  * magnitude, making this well worth it.
+ *
+ * Furthermore, support has later been added to dynamically unregister such intermediate nodes which no longer have
+ * any effects attached to them, which almost completely eliminates the above downside, at the cost of making
+ * `getUntracked` more expensive on such nodes when called frequently, and a bit more internal bookkeeping.
  */
 internal object MarkThenPushAndPullImpl : Impl {
     override fun <T> mutableState(value: T): MutableState<T> {
@@ -132,6 +136,40 @@ private class Node<T>(
     private val dependents: Sequence<Node<*>>
         get() = allDependents.asSequence().filterNot { it.suspended }.mapNotNull { it.dependent }
 
+    /**
+     * Tracks how many of [allDependents] have [NodeKind.Effect] nodes attached to them (directly or transitively).
+     * A number of 0 indicates that there are no [NodeKind.Effect] nodes observing this value in any way, so we don't
+     * actually need to update it when one of its dependencies changes (we can defer that update until someone actually
+     * wants the value).
+     *
+     * This intentionally uses [allDependents] rather than [dependents] and ignores the [Edge.suspended] flag for the
+     * same reason that flag exists in the first place: When re-evaluating a node, we don't want to have to decrement
+     * this counter on all its dependencies (and potentially their transitive dependencies), only to then likely have
+     * to increment it again on most of them as the node re-subscribes to the same nodes again.
+     * Instead we'll only update this counter when we also update the actual [allDependents] list.
+     */
+    private var dependentsWithEffects = if (kind == NodeKind.Effect) 1 else 0
+        set(value) {
+            if (field == 0 && value > 0) {
+                for (edge in allDependencies) {
+                    edge.dependency.dependentsWithEffects++
+                }
+            } else if (field > 0 && value == 0) {
+                for (edge in allDependencies) {
+                    edge.dependency.dependentsWithEffects--
+                }
+                // Note: We must not yet unregister our dependency edges here!
+                // For one, that'll likely result in a ConcurrentModificationException,
+                // but more importantly, if we do that, then we won't know whether our value is up-to-date any more.
+                // One of our dependencies could change, and we wouldn't know about it. So effectively we'd have
+                // to re-compute all such effects on every call to `getUntracked`, which would be very expensive.
+                // Instead we'll stay subscribed even when there's no downstream `effect` any more, and only
+                // unsubscribe once we know we're Dirty.
+                // This is handled in [markDirty].
+            }
+            field = value
+        }
+
     override fun Observer.get(): T {
         return getTracked(this@get)
     }
@@ -165,6 +203,10 @@ private class Node<T>(
         dependency.allDependents.add(edge)
         dependent.allDependencies.add(edge)
 
+        if (dependent.dependentsWithEffects > 0) {
+            dependency.dependentsWithEffects++
+        }
+
         // To prevent unbounded growth, we'll clean up any stale edges whenever we add a new one
         // (this is really fast in when there isn't anything to do thanks to the ReferenceQueue)
         cleanupStaleReferences()
@@ -207,7 +249,28 @@ private class Node<T>(
             NodeState.Dirty, NodeState.Dead -> return // already dirty, nothing to do
         }
 
-        update.queueNode(this)
+        // The node is dirty. If any effect is observing it, it needs to be updated.
+        if (dependentsWithEffects > 0) {
+            update.queueNode(this)
+        } else {
+            // otherwise we can defer updating until someone actually needs its value.
+
+            // We can now also dispose of all our dependency edges.
+            // The only thing our dependencies could do with those edges is try to mark us as ToBeChecked or Dirty,
+            // but we're already Dirty, so that wouldn't change anything.
+            // And by disposing of these edges, we reduce the amount of downstream dependents which our dependencies
+            // have to mark on every change.
+            // See also the `Note` comment in the implementation of [dependentsWithEffects].
+            for (edge in allDependencies) {
+                // We cannot remove the edge from `edge.allDependents` directly, because the caller is likely iterating
+                // over that list right now.
+                // We can mark it as garbage collected though, and let the existing stale edge cleanup code deal with
+                // it automatically.
+                edge.clear() // sets reference value to `null`, so the edge appears as stale
+                edge.enqueue() // enqueues edge in its ReferenceQueue, so cleanupStaleReferences will do something
+            }
+            allDependencies.clear()
+        }
 
         state = NodeState.Dirty
     }
@@ -254,6 +317,9 @@ private class Node<T>(
             allDependencies.removeIf { edge ->
                 if (edge.suspended) {
                     edge.dependency.allDependents.remove(edge)
+                    if (dependentsWithEffects > 0) {
+                        edge.dependency.dependentsWithEffects--
+                    }
                     true
                 } else {
                     false
@@ -276,6 +342,7 @@ private class Node<T>(
 
         for (edge in allDependencies) {
             edge.dependency.allDependents.remove(edge)
+            edge.dependency.dependentsWithEffects--
         }
         allDependencies.clear()
 
@@ -296,7 +363,19 @@ private class Node<T>(
         @Suppress("ControlFlowWithEmptyBody")
         while (queue.poll() != null);
 
-        allDependents.removeIf { it.dependent == null }
+        var updatedEffectsCount = 0
+        allDependents.removeIf { edge ->
+            val dependent = edge.dependent
+            if (dependent == null) {
+                true
+            } else {
+                if (dependent.dependentsWithEffects > 0) {
+                    updatedEffectsCount += 1
+                }
+                false
+            }
+        }
+        dependentsWithEffects = updatedEffectsCount
     }
 
     /**

elementa/statev2/src/main/kotlin/gg/essential/gui/elementa/state/v2/time.kt

@@ -70,19 +70,7 @@ class StateScheduler(val time: State<Instant>) {
         var trigger = triggerCache[bitsMatching]
         if (trigger == null || trigger.first != nextWakeupTime) {
             trigger = Pair(nextWakeupTime, memo {
-                // FIXME States are currently not un-registered when they no longer have any subscribers, only once
-                //  garbage collections deletes them, this is usually good enough but here (and especially during tests)
-                //  it can result in a lot more than 64 states being registered to the root time source state. To avoid
-                //  that, we skip subscribing to the root time source state altogether when our target time has been
-                //  reached, thereby explicitly removing the subscription of this memo from the root time source state.
-                //  Should the State implementation ever be optimized to handle this itself, this can be simplified to:
-                //    timeSource() >= nextWakeupTime
-                if (time.getUntracked() >= nextWakeupTime) {
-                    true
-                } else {
-                    time()
-                    false
-                }
+                time() >= nextWakeupTime
             }.let {
                 // FIXME while a single `memo` is functionality sufficient to decouple evaluation of the subscribers
                 //  from the time source State, a second `memo` is required due to current implementation details of

elementa/statev2/src/test/kotlin/gg/essential/gui/elementa/state/v2/MemoTest.kt

@@ -46,16 +46,14 @@ class MemoTest {
         assertEquals(1, ran, "memo result should be memoized")
 
         state.set(1)
-        // Ideally we wouldn't run the computation if no one is subscribed, current implementation does though
-        // assertEquals(1, ran, "memo should not be updated if no one is subscribed")
+        assertEquals(1, ran, "memo should not be updated if no one is subscribed")
         assertEquals(2, memoState.getUntracked())
         assertEquals(2, ran, "memo should only be evaluated once")
         assertEquals(2, memoState.getUntracked())
         assertEquals(2, ran, "memo result should be memoized")
 
         state.set(2)
-        // Ideally we wouldn't run the computation if no one is subscribed, current implementation does though
-        // assertEquals(2, ran, "memo should not be updated if no one is subscribed")
+        assertEquals(2, ran, "memo should not be updated if no one is subscribed")
         assertEquals(3, memoState.getUntracked())
         assertEquals(3, ran, "memo should only be evaluated once")
         assertEquals(3, memoState.getUntracked())

gradle.properties

@@ -11,4 +11,4 @@ minecraftVersion=11202
 # TODO remove once upgrading to Loom 1.10
 # fabric-api 1.21.5 was built with Loom 1.10, seems to work well enough in dev with our current 1.7 though
 loom.ignoreDependencyLoomVersionValidation=true
-version=1.4.0.3
+version=1.4.1