nested criteria for ideas

src/commonMain/kotlin/core/ai/composableExp/AIPackage.kt

@@ -6,6 +6,10 @@ import core.thing.Thing
 //How does priority work? Is it just based on order definition? Then what about sub modules
 //If everything is order based, then all top level ideas happen before any children, and children are priority per order
 //Could also provide priority override map of name to priority (string,Int)
+//give a base priority, and then packages can override that priority, with the top package overriding the override of a child package
+//When evaluating which idea to go with, map all ideas by priority, and grab the first idea that matches at a given priority list (or random at that level?)
+
+//TODO - make name unique by prefixing it with parant ai package? How do we prevent name collisions?
 data class Idea(val name: String, val criteria: suspend (Thing) -> Boolean, val action: suspend (Thing) -> List<Event>)
 
 //TODO - we can validate string references before flattening

src/commonMain/kotlin/core/ai/composableExp/AIPackageTemplateBuilder.kt

@@ -13,6 +13,7 @@ import core.thing.Thing
 class AIPackageTemplateBuilder(val name: String) {
     private val templates = mutableListOf<String>()
     private val ideas = mutableListOf<Idea>()
+    private val criteriaChildren = mutableMapOf<suspend (Thing) -> Boolean, IdeasBuilder>()
 
 
     fun build(): AIPackageTemplate {
@@ -25,9 +26,29 @@ class AIPackageTemplateBuilder(val name: String) {
         ideas.add(IdeaBuilder(name).apply(initializer).build())
     }
 
+    fun criteria(criteria: suspend (Thing) -> Boolean, initializer: IdeasBuilder.() -> Unit){
+        criteriaChildren[criteria] = IdeasBuilder().apply(initializer)
+    }
+
 }
 
 //DO list of
 fun aiPackage(name: String, initializer: AIPackageTemplateBuilder.() -> Unit): AIPackageTemplate {
     return AIPackageTemplateBuilder(name).apply(initializer).build()
+}
+
+class AIPackageTemplatesBuilder {
+    internal val children = mutableListOf<AIPackageTemplateBuilder>()
+    fun aiPackage(item: AIPackageTemplateBuilder){
+        children.add(item)
+    }
+
+    fun aiPackage(name: String, initializer: AIPackageTemplateBuilder.() -> Unit){
+        children.add(AIPackageTemplateBuilder(name).apply(initializer))
+    }
+
+}
+
+fun aiPackages(initializer: AIPackageTemplatesBuilder.() -> Unit): List<AIPackageTemplate> {
+    return AIPackageTemplatesBuilder().apply(initializer).children.map { it.build() }
 }

src/commonMain/kotlin/core/ai/composableExp/IdeaBuilder.kt

@@ -2,13 +2,14 @@ package core.ai.composableExp
 
 import core.events.Event
 import core.thing.Thing
+import kotlinx.coroutines.NonCancellable.children
 
 class IdeaBuilder(val name: String) {
-    private var criteria: suspend (Thing) -> Boolean = { true }
+    internal var criteria: suspend (Thing) -> Boolean = { true }
     private var action: suspend (Thing) -> List<Event> = { listOf() }
 
 
-    fun build() = Idea(name, criteria, action)
+    fun build(packageName: String) = Idea("$packageName-$name", criteria, action)
 
     fun criteria(criteria: suspend (Thing) -> Boolean) {
         this.criteria = criteria
@@ -24,3 +25,32 @@ class IdeaBuilder(val name: String) {
 
 }
 
+class IdeasBuilder {
+    private val children = mutableListOf<IdeaBuilder>()
+    private val criteriaChildren = mutableMapOf<suspend (Thing) -> Boolean, IdeasBuilder>()
+
+    fun getChildren(parentCriteria: suspend (Thing) -> Boolean = { true }): List<IdeaBuilder> {
+        children.forEach {  it.criteria = { thing -> parentCriteria(thing) && it.criteria(thing) } }
+
+        return children + criteriaChildren.flatMap { (criteria, child) ->
+            child.getChildren { thing -> parentCriteria(thing) && criteria(thing) }
+        }
+    }
+
+    fun idea(item: IdeaBuilder) {
+        children.add(item)
+    }
+
+    fun idea(name: String, initializer: IdeaBuilder.() -> Unit) {
+        children.add(IdeaBuilder(name).apply(initializer))
+    }
+
+    fun criteria(criteria: suspend (Thing) -> Boolean, initializer: IdeasBuilder.() -> Unit) {
+        criteriaChildren[criteria] = IdeasBuilder().apply(initializer)
+    }
+
+}
+
+fun ideas(initializer: IdeasBuilder.() -> Unit): List<IdeaBuilder> {
+    return IdeasBuilder().apply(initializer).getChildren()
+}

src/commonMain/kotlin/core/ai/composableExp/TestSheet.kt

@@ -1,17 +1,30 @@
 package core.ai.composableExp
 
+import status.rest.RestEvent
 import use.eat.EatFoodEvent
 
 fun testAiPackages() {
     aiPackages {
         aiPackage("animal") {
-            idea("eat") {
-                criteria { !it.isSafe() }
-                action { EatFoodEvent(it, it) }
+            criteria({ !it.isSafe() }) {
+                criteria({ !it.isSafe() }) {
+                    idea("eat") {
+                        criteria { !it.isSafe() }
+                        action { EatFoodEvent(it, it) }
+                    }
+                    idea("wait") {
+                        criteria { !it.isSafe() }
+                        action { EatFoodEvent(it, it) }
+                    }
+                }
             }
         }
         aiPackage("predator") {
             template("animal")
+            idea("hunt") {
+                criteria { it.soul.getConditions().isEmpty() }
+                action { RestEvent(it, 1) }
+            }
         }
     }
 }