ai/ktx.ai

Package-level declarations

Types

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.TYPE_PARAMETER, AnnotationTarget.FUNCTION, AnnotationTarget.TYPE, AnnotationTarget.TYPEALIAS])

annotation class GdxAiDsl

Should annotate builder methods of gdxAI.

GdxAiRandom

typealias GdxAiRandom<E> = Random<E>

Alias for com.badlogic.gdx.ai.btree.decorator.Random to avoid name collisions with the standard library.

GdxAiSelector

typealias GdxAiSelector<E> = Selector<E>

Alias for com.badlogic.gdx.ai.btree.branch.Selector to avoid name collisions with the standard library.

GdxAiSequence

typealias GdxAiSequence<E> = Sequence<E>

Alias for com.badlogic.gdx.ai.btree.branch.Sequence to avoid name collisions with the standard library.

Functions

add

inline fun <E, T : Task<E>> Task<E>.add(task: T, init: T.() -> Unit = {}): Int

Adds a task to the receiver Task.

alwaysFail

inline fun <E> Task<E>.alwaysFail(task: Task<E>? = null, init: AlwaysFail<E>.() -> Unit = {}): Int

Creates and adds an AlwaysFail to the receiver Task.

alwaysSucceed

inline fun <E> Task<E>.alwaysSucceed(task: Task<E>? = null, init: AlwaysSucceed<E>.() -> Unit = {}): Int

Creates and adds an AlwaysSucceed to the receiver Task.

behaviorTree

inline fun <E> behaviorTree(rootTask: Task<E>? = null, blackboard: E? = null, init: BehaviorTree<E>.() -> Unit = {}): BehaviorTree<E>

Creates a BehaviorTree.

dynamicGuardSelector

inline fun <E> Task<E>.dynamicGuardSelector(tasks: Array<Task<E>> = Array(), init: DynamicGuardSelector<E>.() -> Unit = {}): Int

Creates and adds a DynamicGuardSelector to the receiver Task.

failureLeaf

inline fun <E> Task<E>.failureLeaf(init: Failure<E>.() -> Unit = {}): Int

Creates and adds a Failure to the receiver Task.

include

inline fun <E> Task<E>.include(subtree: String? = null, lazy: Boolean = false, init: Include<E>.() -> Unit = {}): Int

Creates and adds an Include to the receiver Task.

invert

inline fun <E> Task<E>.invert(task: Task<E>? = null, init: Invert<E>.() -> Unit = {}): Int

Creates and adds an Invert to the receiver Task.

parallel

inline fun <E> Task<E>.parallel(policy: Parallel.Policy = Policy.Sequence, orchestrator: Parallel.Orchestrator = Orchestrator.Resume, tasks: Array<Task<E>> = Array(), init: Parallel<E>.() -> Unit = {}): Int

Creates and adds a Parallel to the receiver Task.

random

inline fun <E> Task<E>.random(success: FloatDistribution = ConstantFloatDistribution.ZERO_POINT_FIVE, task: Task<E>? = null, init: GdxAiRandom<E>.() -> Unit = {}): Int

Creates and adds a GdxAiRandom to the receiver Task.

randomSelector

inline fun <E> Task<E>.randomSelector(tasks: Array<Task<E>> = Array(), init: RandomSelector<E>.() -> Unit = {}): Int

Creates and adds a RandomSelector to the receiver Task.

randomSequence

inline fun <E> Task<E>.randomSequence(tasks: Array<Task<E>> = Array(), init: RandomSequence<E>.() -> Unit = {}): Int

Creates and adds a RandomSequence to the receiver Task.

repeat

inline fun <E> Task<E>.repeat(times: IntegerDistribution = ConstantIntegerDistribution.NEGATIVE_ONE, task: Task<E>? = null, init: Repeat<E>.() -> Unit = {}): Int

Creates and adds a Repeat to the receiver Task.

selector

inline fun <E> Task<E>.selector(tasks: Array<Task<E>> = Array(), init: GdxAiSelector<E>.() -> Unit = {}): Int

Creates and adds a GdxAiSelector to the receiver Task.

semaphoreGuard

inline fun <E> Task<E>.semaphoreGuard(name: String? = null, task: Task<E>? = null, init: SemaphoreGuard<E>.() -> Unit = {}): Int

Creates and adds a SemaphoreGuard to the receiver Task.

sequence

inline fun <E> Task<E>.sequence(tasks: Array<Task<E>> = Array(), init: GdxAiSequence<E>.() -> Unit = {}): Int

Creates and adds a GdxAiSequence to the receiver Task.

successLeaf

inline fun <E> Task<E>.successLeaf(init: Success<E>.() -> Unit = {}): Int

Creates and adds a Success to the receiver Task.

untilFail

inline fun <E> Task<E>.untilFail(task: Task<E>? = null, init: UntilFail<E>.() -> Unit = {}): Int

Creates and adds an UntilFail to the receiver Task.

untilSuccess

inline fun <E> Task<E>.untilSuccess(task: Task<E>? = null, init: UntilSuccess<E>.() -> Unit = {}): Int

Creates and adds an UntilSuccess to the receiver Task.

waitLeaf

inline fun <E> Task<E>.waitLeaf(seconds: FloatDistribution = ConstantFloatDistribution.ZERO, init: Wait<E>.() -> Unit = {}): Int

inline fun <E> Task<E>.waitLeaf(seconds: Float, init: Wait<E>.() -> Unit = {}): Int

Creates and adds a Wait to the receiver Task.