added back repeated input feature on keeping down a key

src/battle-scene.ts

@@ -170,11 +170,6 @@ export default class BattleScene extends SceneBase {
 	private bgmResumeTimer: Phaser.Time.TimerEvent;
 	private bgmCache: Set<string> = new Set();
 	private playTimeTimer: Phaser.Time.TimerEvent;
-	
-	private lastProcessedButtonPressTimes: Map<Button, number> = new Map();
-	// movementButtonLock ensures only a single movement key is firing repeated inputs
-	// (i.e. by holding down a button) at a time
-	private movementButtonLock: Button;
 
 	public rngCounter: integer = 0;
 	public rngSeedOverride: string = '';
@@ -248,7 +243,7 @@ export default class BattleScene extends SceneBase {
 		this.ui?.update();
 	}
 
-	listenInputs() {
+	listenInputs(): void {
 		this.inputController.events.on('input_down', (event) => {
 			const actions = this.getActionsKeyDown();
 			if (!actions.hasOwnProperty(event.button)) return;
@@ -1281,45 +1276,41 @@ export default class BattleScene extends SceneBase {
 		return biomes[Utils.randSeedInt(biomes.length)];
 	}
 
-	buttonDirection(direction) {
+	buttonDirection(direction): Array<boolean | number> {
 		const inputSuccess = this.ui.processInput(direction);
 		const vibrationLength = 5;
-		this.setLastProcessedMovementTime(direction);
 		return [inputSuccess, vibrationLength];
 	}
 
-	buttonAb(button) {
+	buttonAb(button): Array<boolean | number> {
 		const inputSuccess = this.ui.processInput(button);
-		this.setLastProcessedMovementTime(button);
 		return [inputSuccess, 0];
 	}
 
-	buttonTouch() {
+	buttonTouch(): Array<boolean | number> {
 		const inputSuccess = this.ui.processInput(Button.SUBMIT) || this.ui.processInput(Button.ACTION);
-		this.setLastProcessedMovementTime(Button.SUBMIT);
 		return [inputSuccess, 0];
 	}
 
-	buttonStats(pressed = true) {
+	buttonStats(pressed = true): Array<boolean | number> {
 		if (pressed) {
 			for (let p of this.getField().filter(p => p?.isActive(true)))
 				p.toggleStats(true);
-				this.setLastProcessedMovementTime(Button.STATS);
 		} else {
 			for (let p of this.getField().filter(p => p?.isActive(true)))
 				p.toggleStats(false);
 		}
-		return [0, 0];
+		return [true, 0];
 	}
 
-	buttonMenu() {
+	buttonMenu(): Array<boolean | number> {
 		let inputSuccess;
 		if (this.disableMenu)
-			return [0, 0];
+			return [true, 0];
 		switch (this.ui?.getMode()) {
 			case Mode.MESSAGE:
 				if (!(this.ui.getHandler() as MessageUiHandler).pendingPrompt)
-					return [0, 0];
+					return [true, 0];
 			case Mode.TITLE:
 			case Mode.COMMAND:
 			case Mode.FIGHT:
@@ -1342,23 +1333,21 @@ export default class BattleScene extends SceneBase {
 				inputSuccess = true;
 				break;
 			default:
-				return [0, 0];
+				return [true, 0];
 		}
 		return [inputSuccess, 0];
 	}
 
-	buttonCycleOption(button) {
+	buttonCycleOption(button): Array<boolean | number> {
 		let inputSuccess;
 		if (this.ui?.getHandler() instanceof StarterSelectUiHandler) {
 			inputSuccess = this.ui.processInput(button);
-			this.setLastProcessedMovementTime(button);
 		}
 		return [inputSuccess, 0];
 	}
 
-	buttonSpeedChange(up= true) {
+	buttonSpeedChange(up= true): Array<boolean | number> {
 		if (up) {
-			console.log('speed up');
 			if (this.gameSpeed < 5) {
 				this.gameData.saveSetting(Setting.Game_Speed, settingOptions[Setting.Game_Speed].indexOf(`${this.gameSpeed}x`) + 1);
 				if (this.ui?.getMode() === Mode.SETTINGS)
@@ -1367,7 +1356,6 @@ export default class BattleScene extends SceneBase {
 			return [0, 0];
 		}
 		if (this.gameSpeed > 1) {
-			console.log('speed down');
 			this.gameData.saveSetting(Setting.Game_Speed, Math.max(settingOptions[Setting.Game_Speed].indexOf(`${this.gameSpeed}x`) - 1, 0));
 			if (this.ui?.getMode() === Mode.SETTINGS)
 				(this.ui.getHandler() as SettingsUiHandler).show([]);
@@ -1403,12 +1391,6 @@ export default class BattleScene extends SceneBase {
 		return actions;
 	}
 
-
-	setLastProcessedMovementTime(button: Button) {
-		this.lastProcessedButtonPressTimes.set(button, this.time.now);
-		this.movementButtonLock = button;
-	}
-
 	isBgmPlaying(): boolean {
 		return this.bgm && this.bgm.isPlaying;
 	}

src/inputsController.ts

@@ -1,4 +1,4 @@
-import Phaser from "phaser";
+import Phaser, { Time } from "phaser";
 import * as Utils from "./utils";
 import {initTouchControls} from './touch-controls';
 import pad_generic from "#app/configs/pad_generic";
@@ -26,27 +26,41 @@ export enum Button {
     SPEED_UP,
     SLOW_DOWN
 }
+const repeatInputDelayMillis = 250;
 
 export class InputsController extends Phaser.Plugins.ScenePlugin {
 	private game: Phaser.Game;
-	private buttonKeys;
+	private buttonKeys: Phaser.Input.Keyboard.Key[][];
-	private gamepads;
+	private gamepads: Array<string> = new Array();
-	private scene;
+	private scene: Phaser.Scene;
-	private isButtonPressing;
+
+	// buttonLock ensures only a single movement key is firing repeated inputs
+	// (i.e. by holding down a button) at a time
+	private buttonLock: Button;
+	private interactions: Map<Button, Map<string, boolean>> = new Map();
+	private time: Time;
 
     constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager, pluginKey: string) {
 		super(scene, pluginManager, pluginKey);
 		this.game = pluginManager.game;
 		this.scene = scene;
-		// Keys object to store Phaser key objects. We'll check these during update
+		this.time = this.scene.time;
-		this.buttonKeys = {};
+		this.buttonKeys = [];
-		this.gamepads = [];
+
-		this.isButtonPressing = false;
+		for (const b of Utils.getEnumValues(Button)) {
+			this.interactions[b] = {
+				pressTime: false,
+				isPressed: false,
+			}
+		}
+		delete this.interactions[Button.MENU];
+		delete this.interactions[Button.SUBMIT];
     }
 
 	boot() {
 		this.eventEmitter = this.systems.events;
 		this.events = new Phaser.Events.EventEmitter();
+		this.game.events.on(Phaser.Core.Events.STEP, this.update, this);
 
 		if (typeof this.systems.input.gamepad !== 'undefined') {
 			this.systems.input.gamepad.on('connected', function (thisGamepad) {
@@ -59,7 +73,6 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 			if (this.systems.input.gamepad.total) {
 				this.refreshGamepads();
 				for (const thisGamepad of this.gamepads) {
-					console.log('thisGamepad', thisGamepad);
 					this.systems.input.gamepad.emit('connected', thisGamepad);
 				}
 			}
@@ -72,6 +85,19 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 		this.setupKeyboardControls();
 	}
 
+	update() {
+		for (const b of Utils.getEnumValues(Button)) {
+			if (!this.interactions.hasOwnProperty(b)) continue;
+			if (this.repeatInputDurationJustPassed(b)) {
+				this.events.emit('input_down', {
+					controller_type: 'keyboard',
+					button: b,
+				});
+				this.setLastProcessedMovementTime(b);
+			}
+		}
+	}
+
 	setupGamepad(thisGamepad) {
 		let gamepadID = thisGamepad.id.toLowerCase();
 		const mappedPad = this.mapGamepad(gamepadID);
@@ -116,24 +142,24 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 	gamepadButtonDown(pad, button, value) {
 		const actionMapping = this.getActionGamepadMapping();
 		const buttonDown = actionMapping.hasOwnProperty(button.index) && actionMapping[button.index];
-		if (buttonDown !== undefined && !this.isButtonPressing) {
+		if (buttonDown !== undefined) {
-			this.isButtonPressing = true;
 			this.events.emit('input_down', {
 				controller_type: 'gamepad',
 				button: buttonDown,
 			});
+			this.setLastProcessedMovementTime(buttonDown);
 		}
 	}
 
 	gamepadButtonUp(pad, button, value) {
 		const actionMapping = this.getActionGamepadMapping();
 		const buttonUp = actionMapping.hasOwnProperty(button.index) && actionMapping[button.index];
-		if (buttonUp !== undefined && this.isButtonPressing) {
+		if (buttonUp !== undefined) {
-			this.isButtonPressing = false;
 			this.events.emit('input_up', {
 				controller_type: 'gamepad',
 				button: buttonUp,
 			});
+			this.delLastProcessedMovementTime(buttonUp);
 		}
 	}
 
@@ -159,8 +185,7 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 			[Button.SLOW_DOWN]: [keyCodes.MINUS]
 		};
 		const mobileKeyConfig = {};
-		this.buttonKeys = [];
+		for (const b of Utils.getEnumValues(Button)) {
-		for (let b of Utils.getEnumValues(Button)) {
 			const keys: Phaser.Input.Keyboard.Key[] = [];
 			if (keyConfig.hasOwnProperty(b)) {
 				for (let k of keyConfig[b])
@@ -177,17 +202,19 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 	listenInputKeyboard() {
 		this.buttonKeys.forEach((row, index) => {
 			for (const key of row) {
-				key.on('down', (event) => {
+				key.on('down', () => {
 					this.events.emit('input_down', {
 						controller_type: 'keyboard',
 						button: index,
 					});
+					this.setLastProcessedMovementTime(index);
 				});
 				key.on('up', () => {
 					this.events.emit('input_up', {
 						controller_type: 'keyboard',
 						button: index,
 					});
+					this.delLastProcessedMovementTime(index);
 				});
 			}
 		})
@@ -209,4 +236,31 @@ export class InputsController extends Phaser.Plugins.ScenePlugin {
 
         return padConfig;
     }
+
+	/**
+	 * repeatInputDurationJustPassed returns true if @param button has been held down long
+	 * enough to fire a repeated input. A button must claim the buttonLock before
+	 * firing a repeated input - this is to prevent multiple buttons from firing repeatedly.
+	 */
+	repeatInputDurationJustPassed(button: Button): boolean {
+		if (this.buttonLock === null || this.buttonLock !== button) {
+			return false;
+		}
+		if (this.time.now - this.interactions[button].pressTime >= repeatInputDelayMillis) {
+			this.buttonLock = null;
+			return true;
+		}
+	}
+
+	setLastProcessedMovementTime(button: Button) {
+		if (!this.interactions.hasOwnProperty(button)) return;
+		this.buttonLock = button;
+		this.interactions[button].pressTime = this.time.now;
+	}
+
+	delLastProcessedMovementTime(button: Button) {
+		if (!this.interactions.hasOwnProperty(button)) return;
+		this.buttonLock = null;
+		this.interactions[button].pressTime = null;
+	}
 }