keebie/scripts/game_keyboard.gd

class_name GameKeyboard extends Node3D

#region variables
@export_group("Node references")
@export var _keys_holder: Node3D
@export var _sfx_player: AudioStreamPlayer3D

@export_group("Key params")
@export var key_size: float = 0.25
@export var key_gap: float = 0.025

@export_group("Animation")
@export var _rot_sod_fzr: Vector3 = Vector3(3, 0.1, 2)
@export var _time_scale: float = 0.5

@export_subgroup("Pressing")
@export var _pressing_lean_pitch: float = 0.05
@export var _pressing_lean_roll: float = 0.01

@export_group("SFX")
@export var _layout_swap_sfx: AudioStream

var alt_layout: bool
var pressed_positions: Dictionary[Vector3, bool]
var anim_time: float

@onready var _gap_to_size_ratio: float = key_gap / key_size

@onready var _default_position: Vector3 = position
@onready var _rot_sod := SecondOrderDynamics.new(_rot_sod_fzr, Vector3.ZERO)
@onready
var _polyphonic := _sfx_player.get_stream_playback() as AudioStreamPlaybackPolyphonic

#endregion


#region builtins
func _ready() -> void:
	_generate_keys(LayoutConfig.layout_rows)


func _process(delta: float) -> void:
	_animate(delta)


func _unhandled_input(event: InputEvent) -> void:
	if event.is_action_pressed("reset_animations"):
		_rot_sod = SecondOrderDynamics.new(_rot_sod_fzr, _default_position)
		return

	if event is not InputEventKey:
		return

	var event_key := event as InputEventKey

	if event_key.echo:
		return

	if (
		event_key.is_pressed()
		and LayoutConfig.is_configuring
		and event_key.physical_keycode >= KEY_KP_0
		and event_key.physical_keycode <= KEY_KP_9
	):
		_swap_layout(event_key.physical_keycode)
		return

	var keycode := event_key.get_physical_keycode_with_modifiers()

	if (
		event_key.is_pressed()
		and (keycode == KEY_SHIFT | KEY_MASK_ALT or keycode == KEY_ALT | KEY_MASK_SHIFT)
	):
		alt_layout = not alt_layout
		print("change layout! " + str(alt_layout))


#endregion


#region key generation
func _generate_keys(layout_rows: Array[Array]) -> void:
	print("generating keys... ", LayoutConfig.current_layout.name())

	for row: Array[KeyProps] in layout_rows:
		_set_row_key_scales_with_gaps(row)

	var rows_amount := layout_rows.size()
	var row_width := _get_row_width(layout_rows[0] as Array[KeyProps])

	for i in range(rows_amount):
		var row := layout_rows[i] as Array[KeyProps]
		_generate_row(row, i, row_width, rows_amount)


func _generate_row(
	row: Array[KeyProps], row_index: int, row_width: float, rows_amount: int
) -> void:
	var key_pos := _get_row_key_starting_pos(row_index, rows_amount, row_width)

	for key_props in row:
		var key_default_pos := Vector3(
			key_pos.x + _get_row_key_pos_offset(key_props), key_pos.y, key_pos.z
		)
		var game_key := GameKey.instantiate_with_props(key_props, key_default_pos, self)
		_keys_holder.add_child(game_key, true)

		key_pos.x += _get_row_key_step(key_props)


func _set_row_key_scales_with_gaps(row: Array[KeyProps]) -> void:
	for key_props in row:
		key_props.width = _get_scale_with_gaps(key_props.width)
		key_props.height = _get_scale_with_gaps(key_props.height)
		key_props.x = _get_scale_with_gaps(key_props.x) + _gap_to_size_ratio
		key_props.y = _get_scale_with_gaps(key_props.y) + _gap_to_size_ratio
		key_props.width2 = _get_scale_with_gaps(key_props.width2)
		key_props.height2 = _get_scale_with_gaps(key_props.height2)
		key_props.x2 = _get_scale_with_gaps(key_props.x2) + _gap_to_size_ratio
		key_props.y2 = _get_scale_with_gaps(key_props.y2) + _gap_to_size_ratio


func _get_scale_with_gaps(key_scale: float) -> float:
	return key_scale + _gap_to_size_ratio * (key_scale - 1)


func _get_row_width(row: Array[KeyProps]) -> float:
	var width: float = 0
	for key_props in row:
		width += key_size * key_props.width
	return width + (row.size() - 1) * key_gap


func _get_row_key_starting_pos(
	row_index: int, rows_amount: int, row_width: float
) -> Vector3:
	var offset_z: float = (
		((rows_amount - 1) * key_size + (rows_amount - 1) * key_gap) / 2
	)
	var key_pos_x: float = -row_width / 2 + key_size / 2
	var key_pos_z: float = row_index * key_size + row_index * key_gap - offset_z
	return Vector3(key_pos_x, 0, key_pos_z)


func _get_row_key_pos_offset(key_props: KeyProps) -> float:
	return (key_size * key_props.width - key_size) / 2 + key_size * key_props.x


func _get_row_key_step(key_props: KeyProps) -> float:
	return key_size * key_props.width + key_gap + key_size * key_props.x


#endregion


#region layout swapping
func _swap_layout(kp_key: Key) -> void:
	if kp_key == KEY_KP_1:
		LayoutConfig.swap_layout(LayoutANSI.name_static())
	elif kp_key == KEY_KP_2:
		LayoutConfig.swap_layout(LayoutANSIVariant.name_static())
	elif kp_key == KEY_KP_3:
		LayoutConfig.swap_layout(LayoutISO.name_static())
	elif kp_key == KEY_KP_4:
		LayoutConfig.swap_layout(LayoutJD40.name_static())
	elif kp_key == KEY_KP_5:
		LayoutConfig.swap_layout(LayoutPlanck.name_static())
	else:
		return
	_regenerate_keys(LayoutConfig.layout_rows)
	_play_sfx(_layout_swap_sfx)


func _regenerate_keys(layout_rows: Array[Array]) -> void:
	print("REgenerating keys... ", LayoutConfig.current_layout.name())

	var config := LayoutConfig.get_config_file()
	var current_keys: Dictionary[Vector2i, GameKey]

	for node in _keys_holder.get_children():
		if node is not GameKey:
			continue
		var game_key := node as GameKey
		var props := game_key.props
		current_keys[Vector2i(props.physical_keycode, props.location)] = game_key

	for row: Array[KeyProps] in layout_rows:
		_set_row_key_scales_with_gaps(row)

	var rows_amount := layout_rows.size()
	var row_width := _get_row_width(layout_rows[0] as Array[KeyProps])

	for i in range(rows_amount):
		var row := layout_rows[i] as Array[KeyProps]
		_regenerate_row(row, i, row_width, rows_amount, current_keys, config)

	for game_key: GameKey in current_keys.values():
		game_key.queue_free()


func _regenerate_row(
	row: Array[KeyProps],
	row_index: int,
	row_width: float,
	rows_amount: int,
	current_keys: Dictionary[Vector2i, GameKey],
	config: ConfigFile,
) -> void:
	var key_pos := _get_row_key_starting_pos(row_index, rows_amount, row_width)

	for key_props in row:
		var key_default_pos := Vector3(
			key_pos.x + (key_size * key_props.width - key_size) / 2,
			key_pos.y,
			key_pos.z
		)
		var dict_key := Vector2i(key_props.physical_keycode, key_props.location)
		if current_keys.has(dict_key):
			var game_key := current_keys[dict_key]
			game_key.load_props(key_props, key_default_pos)
			game_key._default_position = Vector3(
				key_pos.x + _get_row_key_pos_offset(key_props), key_pos.y, key_pos.z
			)
			current_keys.erase(dict_key)
		else:
			if config:
				var props_dict := LayoutConfig.get_key_config_dict(
					key_props.physical_keycode, config
				)
				if props_dict:
					key_props.chars_from_dict(props_dict)

			var game_key := GameKey.instantiate_with_props(
				key_props, key_default_pos, self
			)
			game_key.position = Vector3(
				key_pos.x + _get_row_key_pos_offset(key_props), key_pos.y, key_pos.z
			)
			_keys_holder.add_child(game_key, true)

		key_pos.x += _get_row_key_step(key_props)


#endregion


#region animation
func _animate(delta: float) -> void:
	anim_time += delta * _time_scale
	rotation = _rot_sod.process(delta, _animate_rotation())


func _animate_rotation() -> Vector3:
	var new_rotation := Vector3.ZERO
	for pos: Vector3 in pressed_positions.keys():
		var pos_pressed := pressed_positions[pos]
		if not pos_pressed:
			continue
		new_rotation.z -= pos.x * _pressing_lean_roll
		new_rotation.x += pos.z * _pressing_lean_pitch

	return new_rotation


#endregion


#region sounds
func _play_sfx(stream: AudioStream) -> void:
	_polyphonic.play_stream(stream)
#endregion