On Transition Issues with Multiple Nested States

[SolarMoonQAQ]

`
fun create(player: Player) = createStdLibStateMachine {

    val player = player as LocalPlayer
    
    val none = initialState("none")

    val root = state("root", ChildMode.PARALLEL) {
        state("base") {
            val land = initialState("land") {
                setupMovementStates(player)
            }
            val crouch = state("crouch") {
                setupMovementStates(player)
            }
            val water = state("water") {
                setupMovementStates(player)
            }
            val sky = state("sky") {
                setupMovementStates(player)
            }
            val sit = state("sit")
            val sleep = state("sleep")

            transitionOn<SwitchEvent> {
                targetState = {
                    when {
                        player.vehicle != null -> sit
                        player.isSleeping -> sleep
                        player.abilities.flying -> sky
                        player.isSwimming -> water
                        player.isCrouching -> crouch
                        else -> land
                    }
                }
            }
        }

        state("addon") {

        }
    }

    transitionOn<SwitchEvent> {
        targetState = {
            if (checkPlayingOtherAnim(player)) none else root
        }
    }

    onStateEntry { s, b ->
        val sName = s.name ?: return@onStateEntry
        SparkCore.LOGGER.info(sName)
    }
}

private suspend fun IState.setupMovementStates(player: LocalPlayer) {
    val idle = initialState("$name.idle")
    val walk = state("$name.walk")
    val walkBack = state("$name.walk_back")
    val sprint = state("$name.sprint")

    transitionOn<SwitchEvent> {
        targetState = {
            when {
                player.isSprinting -> sprint
                player.input.down && player.input.moveVector.length() > 0 -> walkBack
                player.input.moveVector.length() > 0 -> walk
                else -> idle
            }
        }
    }
}

As shown in my code, my goal is to:
After entering the root state, select one qualifying substate (land/sky/water...) to enter, then switch between its child states. However, in practice, after entering any substate (e.g., land), it never transitions to other sibling states even when conditions are met. I reviewed the documentation but couldn’t find a solution to this issue. Therefore, I’d like to ask where I went wrong in my implementation.

[nsk90]

Hello, first of all I can see mutiple transitions on SwitchEvent. which one you expect to be triggered?
I have not run the code yet, but by design the most concrete one should be chosen by the library (that one that is deeper in current active state hierarchy) https://kstatemachine.github.io/kstatemachine/pages/transitions/transitions.html#inherit-transitions-by-grouping-states

have you tried enabling logging for the state machine? it should print transitions so you can see what is happening in runtime
https://kstatemachine.github.io/kstatemachine/pages/testing.html#logging

please let me know if it does not help.

[SolarMoonQAQ]

Thanks for your reply!
My state system uses a hierarchical structure. I intend to process each event by starting from the root level → environment state layer (land/sky/water...) → movement state layer (idle/walk/run...).
This results in composite states formatted like land.idle, land.walk, or water.idle. Each event triggers a top-down evaluation from the root to determine the final combined state.

I recently attempted to modify the event handling for movementState (idle/walk/run) by introducing a new SwitchEvent2. Processing both SwitchEvent1 and SwitchEvent2 sequentially in the tick() function resolved my initial issue—environment layer states now update correctly. However, this causes the movement layer states to refresh/re-evaluate repeatedly.

`object PlayerStateAnimMachine {

class SwitchEvent: Event

class SwitchEvent2: Event

@JvmStatic
fun create(player: Player) = createStdLibStateMachine {
    val player = player as LocalPlayer

    val none = initialState("none")

    val root = state("root", ChildMode.PARALLEL) {
        state("base") {
            val land = initialState("land") { setupMovementStates(player) }
            val crouch = state("crouch") { setupMovementStates(player) }
            val water = state("water") { setupMovementStates(player) }
            val sky = state("sky") { setupMovementStates(player) }
            val sit = state("sit")
            val sleep = state("sleep")

            transitionOn<SwitchEvent> {
                targetState = {
                    when {
                        player.vehicle != null -> sit
                        player.isSleeping -> sleep
                        player.abilities.flying -> sky
                        player.isSwimming -> water
                        player.isCrouching -> crouch
                        else -> land
                    }
                }
            }
        }

        state("addon") {

        }
    }

    transitionOn<SwitchEvent> {
        targetState = {
            if (checkPlayingOtherAnim(player)) none else root
        }
    }

    onStateEntry { s, b ->
        val sName = s.name ?: return@onStateEntry
        SparkCore.LOGGER.info(sName)
        SparkRegistries.TYPED_ANIMATION.get(ResourceLocation.parse("${SparkCore.MOD_ID}:${sName}"))?.let {
            val event = NeoForge.EVENT_BUS.post(ChangePresetAnimEvent.PlayerState(player, it, s, 7))
            if (event.isCanceled) return@let
            val anim = event.newAnim ?: event.originAnim
            anim.play(player, event.transitionTime)
            anim.syncToServer(player.id, event.transitionTime)
        }
    }
}

private suspend fun IState.setupMovementStates(player: LocalPlayer) {
    val idle = initialState("$name.idle")
    val walk = state("$name.walk")
    val walkBack = state("$name.walk_back")
    val sprint = state("$name.sprint")

    transitionOn<SwitchEvent2> {
        targetState = {
            when {
                player.isSprinting -> sprint
                player.input.down && player.input.moveVector.length() > 0 -> walkBack
                player.input.moveVector.length() > 0 -> walk
                else -> idle
            }
        }
    }
}

fun checkPlayingOtherAnim(animatable: IAnimatable<*>): Boolean {
    val controller = animatable.animController
    val animNow = controller.getPlayingAnim() ?: return false
    return animNow.name.substringBefore(".") != "state"
}

@JvmStatic
fun progress(player: Player) {
    player.animStateMachine?.processEventBlocking(SwitchEvent())
    player.animStateMachine?.processEventBlocking(SwitchEvent2())
}

}`

[nsk90]

I see, it looks like this is caused by the misuse of transition DSL. Each single Event can be processed only by single transition. There is no top-down flow in event processing mechanism in the library.

A transition can have multiple onTriggered listeners, but only one transition can be triggered by each single event.

To emultate such top-down behavior as you desired, you can declare one top-level transition with transitionConditionally method and analyse activeStates of the state machine in it's callback lamdba to select next state conditionally.