How do I implement fast/slow movement with the Shift-key correctly?

[LegionaryCohort]

Hi,
First of all, great game engine, having a lot of fun playing around with it so far!

Context for my question:
I have a semi-static map (top-down view) and I'm trying to implement input handling that allows the player to move the viewport.
Nothing fancy, just WASD-keys to move the view around. This works great so far.
I'm now trying to add the ability to move the view around faster when pressing the Shift key as well.

So far I've tried the following:

1. Add seperate UserActions for the keys with and without the Shift modifier.
   The UserActions simply set the viewport speed, which in turn is used in onUpdate to move the viewport around.
   This mostly works as expected, however with one caveat. When I press the A key, and then press the Shift key (while still holding the A key down), it does not switch to the fast movement. Vice versa, if I start with Shift-A and then release the Shift key (while still holding the A key), the movement stops entirely for a short moment, then resumes in slow mode.
   The cause appears to be that as long as the A-key remains pressed, the Shift key is not registered. Or in the second scenario, the Shift-A combination is registered and then stops and it takes the engine a short moment to register that the A-key is still being pressed.

private double speed = 0;

@Override
protected void initInput() {
	var moveLeft = new UserAction("Move Camera Left (Slow)") {
		@Override
		protected void onActionBegin() {
			speed = -600;
		}
		@Override
		protected void onActionEnd() {
			speed = 0;
		}
	};
	var moveLeftFast = new UserAction("Move Camera Left (Fast)") {
		@Override
		protected void onActionBegin() {
			speed = -1200;
		}
		@Override
		protected void onActionEnd() {
			speed = 0;
		}
	};
	FXGL.getInput().addAction(moveLeft, KeyCode.A);
	FXGL.getInput().addAction(moveLeftFast, KeyCode.A, InputModifier.SHIFT);
}

@Override
protected void onUpdate(double tpf) {
	FXGL.getGameScene().getViewport().setX(viewport.getX() + speed * tpf);
}

2. Add separate UserActions for the WASD keys and the shift key.
   The WASD keys again set the speed, the shift key sets a factor. In onUpdate the viewport is moved according to speed*factor.
   This simply does not work, as the engine throws an IllegalArgumentException when trying to bind an action to the Shift key.
   If I bind toggleSpeed to a different (valid) key however, this gives me exactly the result I would like to achieve, just with the wrong key.

private double speed = 0;
private double factor = 1;

@Override
protected void initInput() {
	var toggleSpeed = new UserAction("Toggle Camera Speed") {
		@Override
		protected void onActionBegin() {
			factor = 2;
		}
		@Override
		protected void onActionEnd() {
			speed = 1;
		}
	};
	var moveLeft = new UserAction("Move Camera Left") {
		@Override
		protected void onActionBegin() {
			speed = -600;
		}
		@Override
		protected void onActionEnd() {
			speed = 0;
		}
	};
	FXGL.getInput().addAction(toggleSpeed, KeyCode.SHIFT);
	FXGL.getInput().addAction(moveLeft, KeyCode.A);
}

@Override
protected void onUpdate(double tpf) {
	FXGL.getGameScene().getViewport().setX(viewport.getX() + speed * factor * tpf);
}

3. Add a TriggerListener that handles the Shift-logic internally
   The TriggerListener checks for the WASD-keys being pressed. If detected, it will check if the Shift-key is also pressed and set the viewport speed accordingly.
   This does not work, keyTrigger.getModifier() always returns NONE, regardless of whether the Shift key is pressed or not.
   The regular movement works just fine though, the Shift key just seems to never be registered.
   (On that note, this does feel like a bug, although I'm not entirely certain it isn't just me doing something wrong).

private double speed = 0;
private double factor = 1;

@Override
protected void initInput() {
	FXGL.getInput().addTriggerListener(
		new TriggerListener() {
			@Override
			protected void onAction(Trigger trigger) {
				if (trigger.isKey()) {
					var keyTrigger = (KeyTrigger) trigger;
					if (keyTrigger.getKey() == KeyCode.A) {
						speed = -600;
						factor = (keyTrigger.getModifier() == InputModifier.SHIFT) ? 2 : 1;
					}
				}
			}

			@Override
			protected void onActionEnd(Trigger trigger) {
				if (trigger.isKey()) {
					var keyTrigger = (KeyTrigger) trigger;
					if (keyTrigger.getKey() == KeyCode.A) {
						speed = 0;
						factor = 1;
					}
				}
			}
		}
	);
}

@Override
protected void onUpdate(double tpf) {
	FXGL.getGameScene().getViewport().setX(viewport.getX() + speed * factor * tpf);
}

So, my question:
How do I implement the behaviour that I want, i.e. smooth switching between regular and fast movement, without having to release the movement keys in between?
Note that I also tried using the onAction method, rather than the onActionBegin (figuring it might simply be that the single starting tick was the problem), but this made no difference.
I feel like I'm probably missing something obvious or I'm just misusing the API, so if you could give me any pointers on this, that would be great!
(And sorry for the long post, I'm hoping the code samples clarify what I'm doing, or trying to do)

[AlmasB]

Hi,

The following could work:

1. Add a user action that moves left to A and also SHIFT+A. Both actions are identical and just move left.
2. Add a trigger listener (some kotlin code below, should be easy to adapt to java)

            addTriggerListener(object : TriggerListener() {
                override fun onKeyBegin(keyTrigger: KeyTrigger) {
                    if (keyTrigger.key == KeyCode.SHIFT) {
                        speedMult = 5.0
                    }
                }

                override fun onKeyEnd(keyTrigger: KeyTrigger) {
                    if (keyTrigger.key == KeyCode.SHIFT) {
                        speedMult = 1.0
                    }
                }
            })

Let me know if this works.

[AlmasB]

Thanks, I'll give it some thought too. It's a common use case, so would be good to find a solution for it, whether external or internal.

[LegionaryCohort]

Looking a bit into the details of the Input class, it appears the root cause is the first line on the handleReleased(event: InputEvent) method:
val releasedTriggers = activeTriggers.filter { it.isReleased(event) || (it is KeyTrigger && isIllegal(it.key)) }
So basically whenever a key is released, it automatically also considers any of the ILLEGAL_KEYS (CONTROL, SHIFT and ALT) to have been released. This also applies if I'm pressing multiple other keys and release just one.

I've extended my example to include the A and W keys. If I press and hold Shift, A & W at the same time, I get fast movement to the top left corner (✔️), but if I release just the W key while continuing to hold Shift-A, I get slow movement to the left (❌).
The Shift key is effectively terminated, as suspected, when I release any one key of the ones I'm pressing.

[AlmasB]

Yes, you are correct, the right side of the check should read something like this: it is KeyTrigger && it.key == (event as KeyEvent).code. I'll turn this into an issue.

Doesn't solve your case fully I think, but it should fix this bug.

[AlmasB]

I've logged this as #1313
Current tests are passing, so clearly this bug isn't covered. Feel free to write a unit test for this case if you have time, or just note some pseudo code here and I'll adapt.

[LegionaryCohort]

Not sure I have enough time to fit this in right this moment, but I'll look into it as soon as I can.

[LegionaryCohort]

I'll mark this as closed for now and continue further discussion in #1313