#178 one-shot components

Author: Quillraven

src/commonMain/kotlin/com/github/quillraven/fleks/OneShotComponentSystem.kt

@@ -0,0 +1,27 @@
+package com.github.quillraven.fleks
+
+import com.github.quillraven.fleks.World.Companion.family
+
+/**
+ * An [IteratingSystem] that automatically removes any [components][Component]
+ * or [tags][EntityTag] of an [entity][Entity] that are passed as the [types] argument.
+ *
+ * This system is only used internally and is called at the end of a [World.update].
+ */
+class OneShotComponentSystem(
+    private val types: Array<out UniqueId<*>>,
+    world: World,
+) : IteratingSystem(
+    family = family { any(*types) },
+    world = world,
+) {
+
+    override fun onTickEntity(entity: Entity) {
+        entity.configure {
+            types.forEach { componentType ->
+                entity -= componentType
+            }
+        }
+    }
+
+}

src/commonMain/kotlin/com/github/quillraven/fleks/world.kt

@@ -97,6 +97,9 @@ class World internal constructor(
     @PublishedApi
     internal val tagCache = mutableMapOf<Int, UniqueId<*>>()
 
+    // optional system that automatically removes components/tags registered in the WorldConfiguration
+    internal var oneShotComponentSystem: OneShotComponentSystem? = null
+
     init {
         /**
          * Maybe because of design flaws, the world reference of the ComponentService must be
@@ -408,7 +411,7 @@ class World internal constructor(
                 this.recycle(entity)
                 val entitySnapshot = snapshot[versionLookup[it]]
                 if (entitySnapshot != null) {
-                    // snapshot for entity is provided -> create it
+                    // a snapshot for the entity is provided -> create it
                     // note that the id for the entity will be the recycled id from above
                     this.configure(this.create { }, entitySnapshot)
                 }
@@ -449,6 +452,7 @@ class World internal constructor(
                 system.onUpdate()
             }
         }
+        oneShotComponentSystem?.onUpdate()
     }
 
     /**

src/commonMain/kotlin/com/github/quillraven/fleks/worldCfg.kt

@@ -154,11 +154,20 @@ class WorldConfiguration(@PublishedApi internal val world: World) {
         world.entityService.entityProvider = world.run(factory)
     }
 
+    /**
+     * Registers the given [components][Component]/[tags][EntityTag] as
+     * one-shot, meaning that they are automatically removed from an [entity][Entity]
+     * at the end of [World.update].
+     */
+    fun oneShotComponents(vararg types: UniqueId<*>) {
+        world.oneShotComponentSystem = OneShotComponentSystem(types, world)
+    }
+
     /**
      * Configures the world in the following sequence:
-     * - injectables
-     * - family
-     * - system
+     * - Injectable
+     * - Family
+     * - System
      *
      * The order is important to correctly trigger [FamilyHook]s and [EntityHook]s.
      */

src/commonTest/kotlin/com/github/quillraven/fleks/OneShotComponentSystemTest.kt

@@ -0,0 +1,93 @@
+package com.github.quillraven.fleks
+
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+private class OneShotComp : Component<OneShotComp> {
+    override fun type() = OneShotComp
+
+    companion object : ComponentType<OneShotComp>()
+}
+
+private data object OneShotTag : EntityTag()
+
+private class NormalComp : Component<NormalComp> {
+    override fun type() = NormalComp
+
+    companion object : ComponentType<NormalComp>()
+}
+
+internal class OneShotComponentSystemTest {
+    @Test
+    fun oneShotComponentShouldGetRemovedAfterOnUpdate() {
+        val world = configureWorld {
+            oneShotComponents(OneShotComp)
+        }
+        val entity = world.entity { it += OneShotComp() }
+
+        with(world) {
+            assertTrue { entity has OneShotComp }
+
+            world.update(0f)
+
+            assertFalse { entity has OneShotComp }
+        }
+    }
+
+    @Test
+    fun oneShotTagShouldGetRemovedAfterOnUpdate() {
+        val world = configureWorld {
+            oneShotComponents(OneShotTag)
+        }
+        val entity = world.entity { it += OneShotTag }
+
+        with(world) {
+            assertTrue { entity has OneShotTag }
+
+            world.update(0f)
+
+            assertFalse { entity has OneShotTag }
+        }
+    }
+
+    @Test
+    fun normalComponentShouldNotGetRemovedAfterOnUpdate() {
+        val world = configureWorld {
+            oneShotComponents(OneShotComp)
+        }
+        val entity = world.entity { it += NormalComp() }
+
+        with(world) {
+            assertTrue { entity has NormalComp }
+
+            world.update(0f)
+
+            assertTrue { entity has NormalComp }
+        }
+    }
+
+    @Test
+    fun listOfOneShotsShouldGetRemovedAfterOnUpdate() {
+        val world = configureWorld {
+            oneShotComponents(OneShotComp, OneShotTag)
+        }
+        val entity = world.entity {
+            it += NormalComp()
+            it += OneShotComp()
+            it += OneShotTag
+        }
+
+        with(world) {
+            assertTrue { entity has NormalComp }
+            assertTrue { entity has OneShotComp }
+            assertTrue { entity has OneShotTag }
+
+            world.update(0f)
+
+            assertTrue { entity has NormalComp }
+            assertFalse { entity has OneShotComp }
+            assertFalse { entity has OneShotTag }
+        }
+    }
+}