Java's Enums are infuriating. If you have an instance of an Enum, there is no way to enumerate all possible values. Isn't that ironic given 'Enum' is short for enumeration. You need the Enum's type (at compile-time, which Kyd doesn't have)

FileResource

interface FileResource : Resource

Folder

class Folder(var parent: ParentResource, name: String) : AbstractParentResource

A ParentResource which has no data of its own, but only acts as a parent for a group of children.

Game

class Game(val filePath: String, val resources: Resources) : AbstractParentOrGame

The root node of a game's tree of resources. Each node in this tree implements the Resource interface.

GridSnapping

class GridSnapping(val sizeX: Float, val sizeY: Float) : Snapping

JarLoader

object JarLoader

KydTypeRegistry

object KydTypeRegistry

Launcher

object Launcher

Link

class Link(var parent: ParentResource, name: String) : AbstractParentResource, ResolvableResource

A reference to another resource (similar to symbolic links in *nix filesystems).

Management

open class Management(val game: Game)

Management exists the entire time that the program is running, and is in charge of the boring nitty-gritty, such as loading Acts.

MouseBehaviour

interface MouseBehaviour : Behaviour

Many Behaviours are never interact with mouse presses, and if we checked every single Role when a mouse was pressed/released, this would be quite expensive (because to convert from screen coordinates to the Actor's local coordinates is non-trivial).

NoBehaviour

object NoBehaviour : Behaviour

NoDirector

object NoDirector : Director

NoSnapping

object NoSnapping : Snapping

ObservableVector2

interface ObservableVector2 : ObservableValue<Vector2>

Boilerplate which avoids having to use generics. Instead of ObservableValue<Vector2>, use ObservableVector2.

Overlapping

interface Overlapping

Checks if two actors overlap each other.

ParentResource

interface ParentResource : Resource

Pick

class Pick(name: String = "")

Picks appear in a side panel of the editor, and can be picked and dropped onto a Stage when editing an Act.

PickGroup

class PickGroup(name: String = "")

PixelOverlapping

class PixelOverlapping(threshold: Float) : Overlapping

Checks that actors bounding rectangles overlap, and then checks if any pixels overlap. i.e. any non-transparent pixels of actorA are in the same place as any non-transparent pixels of actorB.

ReadOnlyVector2Property

interface ReadOnlyVector2Property : ObservableVector2, ReadOnlyProperty<Vector2>

Boilerplate which avoids having to use generics. Instead of ReadOnlyProperty<Vector2>, use ReadOnlyVector2Property.

ReadOnlyVector2PropertyWrapper

class ReadOnlyVector2PropertyWrapper(wraps: Vector2Property) : ReadOnlyPropertyWrapper<Vector2, Property<Vector2>> , ReadOnlyVector2Property

Never use this class directly. Use Vector2Property.asReadOnly to obtain a read-only version of a mutable Vector2Property.

ResolvableResource

interface ResolvableResource : Resource

A Resource which links to other Resources, such as Pose, which links to a Graphic. While loading resources, the Resource only knows the PATH to the linked Resource, not the Resource itself (because that may not be loaded yet). Once the entire file is loaded, resolveReferences is called.

Resource

interface Resource

A Game is the root of a tree structure, with each node of the tree being an Resource. All of a games resources are stored within this tree.

ResourceType

enum ResourceType : Enum<ResourceType>

Role

class Role(var parent: ParentResource, name: String) : AbstractParentResource, ResolvableResource, AppearanceResource

SimpleVector2Property

open class SimpleVector2Property(initialValue: Vector2, bean: Any? = null, beanName: String? = null) : SimpleProperty<Vector2> , Vector2Property

Boilerplate which avoids having to use generics. Instead of SimpleProperty<Vector2>, we can use SimpleVector2Property.

SizeConstraint

enum SizeConstraint : Enum<SizeConstraint>

Snapping

interface Snapping

Stage

open class Stage(val name: String) : ActorParent

StageDescription

class StageDescription

See Game.stageDescriptions

Ticks

interface Ticks

Touching

interface Touching

When a mouse event needs to check if the mouse is "touching" an actor, how is "touching" defined.

TouchingAnd

class TouchingAnd(val a: Touching, val b: Touching) : Touching

Performs 2 Touching tests. If the second test is only carried out if the first test passes.

TouchingChildren

class TouchingChildren(val baseTest: Touching) : Touching

Touching test which also checks the actor's children.

TouchingDescendants

class TouchingDescendants(val baseTest: Touching) : Touching

Checks if an actor or any of its descendant actors are touching the given point.

TouchingPixel

class TouchingPixel(val alphaThreshold: Float) : Touching

Returns true iff the pixel at the given point has a alpha value alphaThreshold.

ValidatedVector2Property

open class ValidatedVector2Property(initialValue: Vector2, bean: Any? = null, beanName: String? = null, validation: (ValidatedProperty<Vector2>, Vector2, Vector2) -> Vector2) : ValidatedProperty<Vector2> , Vector2Property

Boilerplate which avoids having to use generics. Instead of ValidatedProperty<Vector2>, we can use ValidatedVector2Property.

Vector2BinaryFunction

class Vector2BinaryFunction<A, OA : ObservableValue<A>, B, OB : ObservableValue<B>>(argA: OA, argB: OB, lambda: (A, B) -> Vector2) : BinaryFunction<Vector2, A, OA, B, OB> , ObservableVector2

Boilerplate which avoids having to use generics. An ObservableVector2 which is calculated from 2 (binary) other ObservableValues.

Vector2Property

interface Vector2Property : Property<Vector2> , ReadOnlyVector2Property

Boilerplate which avoids having to use generics. Instead of Property<Vector2>, use Vector2Property.

Vector2TernaryFunction

class Vector2TernaryFunction<A, OA : ObservableValue<A>, B, OB : ObservableValue<B>, C, OC : ObservableValue<C>>(argA: OA, argB: OB, argC: OC, lambda: (A, B, C) -> Vector2) : TernaryFunction<Vector2, A, OA, B, OB, C, OC> , ObservableVector2

Boilerplate which avoids having to use generics. An ObservableVector2 which is calculated from 3 (ternary) other ObservableValues.

Vector2UnaryFunction

class Vector2UnaryFunction<A, OA : ObservableValue<A>>(argA: OA, lambda: (A) -> Vector2) : UnaryFunction<Vector2, A, OA> , ObservableVector2

Boilerplate which avoids having to use generics. An ObservableVector2 which is calculated from 1 (unary) other ObservableValue.

WithinBounds

object WithinBounds : Touching

ZOrderStage

class ZOrderStage(val name: String) : Stage

A Stage which automatically orders the Actors by Actor.zOrder.

Properties

degreesToRadians

const val degreesToRadians: Float

ManagementClassName

const val ManagementClassName: String

NoBehaviourClassName

const val NoBehaviourClassName: String

NoDirectorClassName

const val NoDirectorClassName: String

const val Pi: Float = 3.1415927f

radiansToDegrees

const val radiansToDegrees: Float

StageClassName

const val StageClassName: String

Tau

const val Tau: Float

ZOrderStageClassName

const val ZOrderStageClassName: String

Functions

absolutePath

fun absolutePath(path: String, relativeTo: Resource): String

findCustomisableProperties

expect fun findCustomisableProperties(obj: Customisable): List<Property<*>>

actual fun findCustomisableProperties(obj: Customisable): List<Property<*>>

For JVM-only games, it is sufficient to add @Custom to properties. The default implementation of Customisable.customProperties calls this, which uses reflection to find each Property tagged with a Custom annotation.

findCustomisablePropertiesWithCustom

fun findCustomisablePropertiesWithCustom(obj: Customisable): List<Pair<Property<*>, Custom>>

Returns not only the Property, but the Custom attribute too, so that the editor can use Custom.about and Custom.isAct etc.

isRelativePath

fun isRelativePath(path: String): Boolean

loadCode

expect fun loadCode(game: Game)

actual fun loadCode(game: Game)

pathExtension

fun pathExtension(path: String): String

pathName

fun pathName(path: String): String

pathNameWithoutExtension

fun pathNameWithoutExtension(path: String): String

pathParent

fun pathParent(path: String): String?

pathSplitParent

fun pathSplitParent(path: String): Pair<String, String>?

validatedVector2Property

fun validatedVector2Property(initialValue: Vector2, validation: (ValidatedProperty<Vector2>, Vector2, Vector2) -> Vector2): PropertyDelegate<Vector2, Vector2Property>

A Kotlin delegate to create a ValidatedVector2Property. Typical usage :

vector2Property

fun vector2Property(initialValue: Vector2): PropertyDelegate<Vector2, Vector2Property>

A Kotlin delegate to create a Vector2Property (the implementation will be a SimpleVector2Property. Typical usage :