Problem
You want an onscreen display of the last inputs from the player. There should be a fixed amount of history displayed and new inputs scroll the history, adding new entries on the left.
Solution
Store the inputs in a rotating buffer. A fixed segment of memory is dedicated to recording the history and as new inputs are entered, the memory is updated shifting new input to the end.
We set up a scene with a Label control, called Output.
extends Control
var buffer: Array[String] = []
var buf_length = 5
func _ready() -> void:
for i in range(buf_length):
buffer.append(' ')
A simple Array[String] is best for the buffer, we also need to know the fixed length of the buffer, using 5 for this example.
In the _ready function We initialize the buffer with the with blank spaces so the first input will appear at the right and move left with additional inputs.
func _input(ev: InputEvent) -> void:
match ev.get_class():
"InputEventKey" when ev.unicode > 0x60 and ev.unicode < 0x7B:
rotate_buffer(ev.as_text())
write_array()
We use the _input virtual function to capture the key pressed by the user. A match statement to checks the type of the InputEvent (ev), we are checking for keyboard presses in this example so the conditional on line 4 matches only events between lowercase a and z using their unicode hex values.
func rotate_buffer(input: String) -> void:
for i in range(1, buf_length):
buffer[i - 1] = buffer[i]
buffer[buf_length - 1] = input
The core algorithm is defined in rotate_buffer function where elements 1, 2, 3, and 4 of the buffer are shifted down the array. Element 0 is overwritten and discarded.
Finally, we write the input into buffer[4], effectively appending it to the end.
func write_array() -> void:
var output = ''
for i in range(buf_length):
output += buffer[i]
$Output.text = output
To wrap everything up we build the output string from the buffer and assign it to the $Output Label control.
Discussion
The choice of a match conditional is personal preference here. _input functions will often multiple types of input the look for (mouse, controller, keyboard, and others). I think that using a match..when is clearer what a chain of if..elif conditions.
Slicing the Array
Another way to rotate the value in the buffer is to use the slice method before pushing the input to the end with append. Avoid this:
func rotate_buffer(input: String) -> void:
buffer = buffer.slice(1)
buffer.append(input)
Slice creates a new array with every invocation. The new array only has 4 element so when we append the array is resized.
Array creation and resizing are more memory intensive operation than copying value.
You may not always know how big arrays are in you program. However, when they have a fixed size use techniques that maintain the initial memory allocation.
ALL CAPS
If you run this script you will notice that we only match the lowercase letters a-z but the text in the output is always capital A-Z. This is because the Godot Engine’s input handler only cares about physical button presses.
If you want to know if the user intends capital or lowercase, extend the range of the filter in the match predicate and convert the unicode value to a character:
"InputEventKey" when ev.unicode > 0x40 and ev.unicode < 0x7B:
rotate_buffer(String.chr(ev.unicode))
Alternative Applications
The rotate_buffer function is the core to this technique. Simple adjustments to the captured input and formatting of the output can achieve additional results.
For example capturing controller inputs of A, B, X, Y into the buffer. Then Instead of a single Output label, place five Sprite2D nodes in the scene. On every call to write_output loop over the buffer and change the texture of the sprite to match the controller button presses.