Add support for schemas

build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     kotlin("jvm") version "1.8.10"
+    kotlin("plugin.serialization") version "1.8.10"
 }
 
 group = "com.tpcly"
@@ -10,6 +11,7 @@ repositories {
 }
 
 dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
     testImplementation(kotlin("test"))
     testImplementation("io.mockk:mockk:1.13.7")
 }

src/main/kotlin/com/tpcly/behaviourtree/Conditional.kt

@@ -0,0 +1,9 @@
+package com.tpcly.behaviourtree
+
+abstract class Conditional : TreeNode {
+    abstract fun validate(): Boolean
+
+    override fun execute(): TreeNodeStatus {
+        return TreeNodeStatus.fromBoolean(validate())
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/Inverter.kt

@@ -0,0 +1,16 @@
+package com.tpcly.behaviourtree
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Inverter(
+    override val child: TreeNode,
+) : TreeNode.Decorator {
+    override fun execute(): TreeNodeStatus {
+        return when (val result = child.execute()) {
+            TreeNodeStatus.SUCCESS -> TreeNodeStatus.FAILURE
+            TreeNodeStatus.FAILURE -> TreeNodeStatus.SUCCESS
+            else -> result
+        }
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/RepeatUntil.kt

@@ -0,0 +1,29 @@
+package com.tpcly.behaviourtree
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RepeatUntil(
+    override val child: TreeNode,
+    val targetStatus: TreeNodeStatus = TreeNodeStatus.SUCCESS,
+    val limit: Int = 10,
+) : TreeNode.Decorator {
+    override fun execute(): TreeNodeStatus {
+        var iteration = 0
+        var currentStatus: TreeNodeStatus
+
+        do {
+            currentStatus = child.execute()
+            iteration++
+        } while (
+            currentStatus != targetStatus &&
+            currentStatus != TreeNodeStatus.ABORT &&
+            iteration < limit
+        )
+
+        return when {
+            iteration >= limit -> TreeNodeStatus.FAILURE
+            else -> currentStatus
+        }
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/Selector.kt

@@ -0,0 +1,26 @@
+package com.tpcly.behaviourtree
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Selector(
+    val executionOrder: TreeExecutionOrder,
+    override val children: List<TreeNode>,
+) : TreeNode.Composite {
+    override fun execute(): TreeNodeStatus {
+        val children = when (executionOrder) {
+            TreeExecutionOrder.RANDOM -> children.shuffled()
+            else -> children
+        }
+
+        for (child in children) {
+            val result = child.execute()
+
+            if (result == TreeNodeStatus.SUCCESS || result == TreeNodeStatus.ABORT) {
+                return result
+            }
+        }
+
+        return TreeNodeStatus.FAILURE
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/Sequencer.kt

@@ -0,0 +1,26 @@
+package com.tpcly.behaviourtree
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Sequencer(
+    val executionOrder: TreeExecutionOrder,
+    override val children: List<TreeNode>,
+) : TreeNode.Composite {
+    override fun execute(): TreeNodeStatus {
+        val children = when (executionOrder) {
+            TreeExecutionOrder.RANDOM -> children.shuffled()
+            else -> children
+        }
+
+        for (child in children) {
+            val result = child.execute()
+
+            if (result == TreeNodeStatus.FAILURE || result == TreeNodeStatus.ABORT) {
+                return result
+            }
+        }
+
+        return TreeNodeStatus.SUCCESS
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/Succeeder.kt

@@ -0,0 +1,13 @@
+package com.tpcly.behaviourtree
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Succeeder(
+    override val child: TreeNode,
+) : TreeNode.Decorator {
+    override fun execute(): TreeNodeStatus {
+        child.execute()
+        return TreeNodeStatus.SUCCESS
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/TreeBuilder.kt

@@ -0,0 +1,57 @@
+package com.tpcly.behaviourtree
+
+object TreeBuilder {
+    /**
+     * Pre-defined leaf nodes
+     */
+    fun action(execute: () -> TreeNodeStatus): TreeNode = object : TreeNode {
+        override fun execute(): TreeNodeStatus = execute()
+    }
+
+    fun conditional(validate: () -> Boolean): TreeNode = object : TreeNode {
+        override fun execute(): TreeNodeStatus = TreeNodeStatus.fromBoolean(validate())
+    }
+
+    fun perform(execute: () -> Unit): TreeNode = object : TreeNode {
+        override fun execute(): TreeNodeStatus {
+            execute()
+            return TreeNodeStatus.SUCCESS
+        }
+    }
+
+    /**
+     * Composite nodes
+     */
+    fun selector(
+        executionOrder: TreeExecutionOrder = TreeExecutionOrder.IN_ORDER,
+        init: TreeNodeCompositeBuilder.() -> Unit,
+    ): Selector {
+        val builder = TreeNodeCompositeBuilder().apply(init)
+        return Selector(executionOrder, builder.build())
+    }
+
+    fun sequencer(
+        executionOrder: TreeExecutionOrder = TreeExecutionOrder.IN_ORDER,
+        init: TreeNodeCompositeBuilder.() -> Unit,
+    ): Sequencer {
+        val builder = TreeNodeCompositeBuilder().apply(init)
+        return Sequencer(executionOrder, builder.build())
+    }
+
+    /**
+     * Decorator nodes
+     */
+    fun inverter(init: () -> TreeNode) = Inverter(init())
+
+    fun TreeNode.inverted() = Inverter(this)
+
+    fun succeeder(init: () -> TreeNode) = Succeeder(init())
+
+    fun failer(init: () -> TreeNode) = succeeder(init).inverted()
+
+    fun repeatUntil(
+        status: TreeNodeStatus = TreeNodeStatus.SUCCESS,
+        limit: Int = 10,
+        init: () -> TreeNode,
+    ) = RepeatUntil(init(), status, limit)
+}

src/main/kotlin/com/tpcly/behaviourtree/ExecutionOrder.kt → src/main/kotlin/com/tpcly/behaviourtree/TreeExecutionOrder.kt

@@ -1,6 +1,6 @@
 package com.tpcly.behaviourtree
 
-enum class ExecutionOrder {
+enum class TreeExecutionOrder {
     IN_ORDER,
     RANDOM
 }

src/main/kotlin/com/tpcly/behaviourtree/TreeNode.kt

@@ -0,0 +1,21 @@
+package com.tpcly.behaviourtree
+
+interface TreeNode {
+    fun execute(): TreeNodeStatus
+
+    interface Composite : TreeNode {
+        val children: List<TreeNode>
+    }
+
+    interface Decorator : TreeNode {
+        val child: TreeNode
+    }
+
+    interface Sub : TreeNode {
+        val root: TreeNode
+
+        override fun execute(): TreeNodeStatus {
+            return root.execute()
+        }
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/TreeNodeCompositeBuilder.kt

@@ -0,0 +1,17 @@
+package com.tpcly.behaviourtree
+
+class TreeNodeCompositeBuilder {
+    private val children: MutableList<TreeNode> = mutableListOf()
+
+    operator fun TreeNode.unaryPlus() {
+        children += this
+    }
+
+    operator fun TreeNode.unaryMinus() {
+        children -= this
+    }
+
+    fun build(): List<TreeNode> {
+        return children.toList()
+    }
+}

src/main/kotlin/com/tpcly/behaviourtree/TreeNodeStatus.kt

@@ -0,0 +1,11 @@
+package com.tpcly.behaviourtree
+
+enum class TreeNodeStatus {
+    SUCCESS,
+    FAILURE,
+    ABORT;
+
+    companion object {
+        fun fromBoolean(value: Boolean): TreeNodeStatus = if (value) SUCCESS else FAILURE
+    }
+}