379 lines
10 KiB
GDScript
379 lines
10 KiB
GDScript
@tool
|
|
class_name GameKeyboard extends Node3D
|
|
|
|
#region variables
|
|
signal key_pressed(game_key: GameKey)
|
|
signal key_input_event_emitted(game_key: GameKey, event: InputEventKey)
|
|
signal layout_changed(rect: Rect2)
|
|
signal prompt_page_turned(page: int)
|
|
signal keys_queried(query_func: Callable)
|
|
signal configuring_changed(is_configuring: bool)
|
|
signal player_current_key_changed(game_key: GameKey)
|
|
signal player_finished_move(game_key: GameKey)
|
|
|
|
@export_tool_button("Generate keys")
|
|
var generate_editor_keys_btn := _generate_editor_keys
|
|
@export_tool_button("Delete keys") var delete_editor_keys_btn := _delete_editor_keys
|
|
@export_tool_button("Request keys") var query_keys_btn := _query_editor_keys
|
|
|
|
@export_group("References")
|
|
@export var _keys_holder: Node3D
|
|
@export var _sfx_player: AudioStreamPlayer3D
|
|
@export var _rect_mesh: MeshInstance3D
|
|
@export var _key_scene: PackedScene
|
|
|
|
@export_group("Key parameters")
|
|
@export var key_size: float = 1
|
|
@export var key_gap: float = 0.1
|
|
|
|
@export_group("Animation")
|
|
@export var _rot_sod_fzr: Vector3 = Vector3(3, 0.1, 2)
|
|
@export var _anim_time_scale: float = 0.5
|
|
@export var _pressing_lean_deg := Vector2(0.15, 0.7)
|
|
|
|
@export_group("SFX")
|
|
@export var _layout_swap_sfx: AudioStream
|
|
|
|
var is_configuring: bool
|
|
var alt_visual_layout: bool
|
|
var layout_rect: Rect2
|
|
var pressed_positions: Dictionary[Vector3, bool]
|
|
var anim_time: float
|
|
|
|
var prompt_page: int = 0
|
|
var prompt_pages_total: int = 0
|
|
|
|
var _rot_sod: SecondOrderDynamics
|
|
|
|
var _queried_keys: Array[GameKey] = []
|
|
var _queried_keys_limit: int = 0
|
|
|
|
@onready var _gap_to_size_ratio: float
|
|
@onready var _pressing_lean_rad := Vector2(
|
|
deg_to_rad(_pressing_lean_deg.x), deg_to_rad(_pressing_lean_deg.y)
|
|
)
|
|
@onready var _default_rot: Vector3 = _keys_holder.rotation
|
|
@onready var _polyphonic: AudioStreamPlaybackPolyphonic
|
|
|
|
#endregion
|
|
|
|
|
|
#region builtins
|
|
func _ready() -> void:
|
|
if Engine.is_editor_hint():
|
|
_generate_editor_keys()
|
|
return
|
|
_polyphonic = _sfx_player.get_stream_playback()
|
|
prompt_pages_total = ceili(LayoutConfig.layouts.size() / 9.0)
|
|
_generate_game_keys()
|
|
_reset_animations()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if Engine.is_editor_hint():
|
|
return
|
|
_animate(delta)
|
|
|
|
|
|
func _unhandled_input(event: InputEvent) -> void:
|
|
if Engine.is_editor_hint():
|
|
return
|
|
if event.is_action_pressed("reset_animations"):
|
|
_reset_animations()
|
|
return
|
|
if event.is_action_pressed("toggle_configuring"):
|
|
is_configuring = not is_configuring
|
|
print("now configuring: %s" % is_configuring)
|
|
configuring_changed.emit(is_configuring)
|
|
return
|
|
|
|
if event is not InputEventKey:
|
|
return
|
|
|
|
var event_key := event as InputEventKey
|
|
|
|
if event_key.echo or not event_key.is_pressed():
|
|
return
|
|
|
|
if (
|
|
is_configuring
|
|
and event_key.physical_keycode >= KEY_KP_0
|
|
and event_key.physical_keycode <= KEY_KP_9
|
|
):
|
|
_change_layout(event_key.physical_keycode)
|
|
return
|
|
|
|
var keycode := event_key.get_physical_keycode_with_modifiers()
|
|
|
|
if keycode == KEY_SHIFT | KEY_MASK_ALT or keycode == KEY_ALT | KEY_MASK_SHIFT:
|
|
alt_visual_layout = not alt_visual_layout
|
|
print("changed visual layout! " + str(alt_visual_layout))
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region public
|
|
func query_keys(query_func: Callable, limit: int = 0) -> Array[GameKey]:
|
|
_queried_keys = []
|
|
_queried_keys_limit = limit
|
|
|
|
keys_queried.emit(query_func)
|
|
var queried_keys := _queried_keys
|
|
|
|
_queried_keys = []
|
|
_queried_keys_limit = 0
|
|
|
|
queried_keys.sort_custom(KeyHelper.game_key_sort)
|
|
return queried_keys
|
|
|
|
|
|
func query_key_by_keycode(keycode: Key) -> GameKey:
|
|
var found_key: GameKey
|
|
var result := query_keys(
|
|
func(game_key: GameKey) -> bool: return game_key.props.keycode == keycode, 1
|
|
)
|
|
if result:
|
|
found_key = result[0]
|
|
return found_key
|
|
|
|
|
|
func query_keys_by_keycodes(keycodes: Array[Key]) -> Array[GameKey]:
|
|
return query_keys(
|
|
func(game_key: GameKey) -> bool: return game_key.props.keycode in keycodes
|
|
)
|
|
|
|
|
|
func key_query_respond(game_key: GameKey) -> void:
|
|
if _queried_keys_limit == 0 or _queried_keys.size() < _queried_keys_limit:
|
|
_queried_keys.append(game_key)
|
|
|
|
|
|
func emit_key_pressed(game_key: GameKey) -> void:
|
|
key_pressed.emit(game_key)
|
|
|
|
|
|
func emit_key_input_event_emitted(game_key: GameKey, event: InputEventKey) -> void:
|
|
key_input_event_emitted.emit(game_key, event)
|
|
|
|
|
|
func emit_player_current_key_changed(game_key: GameKey) -> void:
|
|
player_current_key_changed.emit(game_key)
|
|
|
|
|
|
func emit_player_finished_move(game_key: GameKey) -> void:
|
|
player_finished_move.emit(game_key)
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region key generation
|
|
func _generate_game_keys() -> void:
|
|
print("generating keys...")
|
|
_iterate_key_props_rows(_generate_game_key, LayoutConfig.layout_key_props_rows)
|
|
|
|
|
|
func _generate_game_key(
|
|
key_props: KeyProps,
|
|
key_pos: Vector3,
|
|
angle: float,
|
|
_current_keys: Dictionary[Vector2i, Array]
|
|
) -> void:
|
|
var game_key := GameKey.instantiate_with_props(
|
|
key_props, key_pos, angle, self, _key_scene
|
|
)
|
|
_keys_holder.add_child(game_key, true)
|
|
|
|
|
|
func _iterate_key_props_rows(
|
|
iter_func: Callable,
|
|
key_props_rows: Array[Array],
|
|
current_keys: Dictionary[Vector2i, Array] = {}
|
|
) -> void:
|
|
_gap_to_size_ratio = key_gap / key_size
|
|
for key_props_row: Array[KeyProps] in key_props_rows:
|
|
_set_row_key_scales_with_gaps(key_props_row)
|
|
|
|
var rect := KeyHelper.iterate_key_props_rows(
|
|
iter_func, key_props_rows, key_size, key_gap, current_keys
|
|
)
|
|
|
|
layout_changed.emit(rect)
|
|
_rect_mesh.scale = Vector3(rect.size.x, 1, rect.size.y)
|
|
_rect_mesh.position.x = rect.position.x + rect.size.x / 2 - rect.get_center().x
|
|
_rect_mesh.position.z = rect.position.x + rect.size.y / 2 - rect.get_center().y
|
|
|
|
|
|
func _set_row_key_scales_with_gaps(key_props_row: Array[KeyProps]) -> void:
|
|
for key_props in key_props_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
|
|
if key_props.has_pivot_x():
|
|
key_props.pivot_x = (
|
|
_get_scale_with_gaps(key_props.pivot_x) + _gap_to_size_ratio
|
|
)
|
|
if key_props.has_pivot_y():
|
|
key_props.pivot_y = (
|
|
_get_scale_with_gaps(key_props.pivot_y) + _gap_to_size_ratio
|
|
)
|
|
|
|
|
|
func _get_scale_with_gaps(key_scale: float) -> float:
|
|
return key_scale + _gap_to_size_ratio * (key_scale - 1)
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region layout swapping
|
|
func _change_layout(kp_key: Key) -> void:
|
|
if kp_key == KEY_KP_0:
|
|
prompt_page = wrapi(prompt_page + 1, 0, prompt_pages_total)
|
|
prompt_page_turned.emit(prompt_page)
|
|
return
|
|
|
|
var layout_idx := kp_key - KEY_KP_1 + prompt_page * 9
|
|
if layout_idx < 0 or layout_idx >= LayoutConfig.layouts.size():
|
|
return
|
|
|
|
var new_layout_name := (
|
|
(LayoutConfig.layouts.values() as Array[AbstractLayout])[layout_idx].get_name()
|
|
)
|
|
|
|
if new_layout_name == LayoutConfig.current_layout.get_name():
|
|
return
|
|
|
|
LayoutConfig.change_layout(new_layout_name)
|
|
_regenerate_keys(LayoutConfig.layout_key_props_rows)
|
|
_play_sfx(_layout_swap_sfx)
|
|
|
|
|
|
func _regenerate_keys(key_props_rows: Array[Array]) -> void:
|
|
print("REgenerating keys...")
|
|
|
|
var current_keys: Dictionary[Vector2i, Array]
|
|
for node in _keys_holder.get_children():
|
|
if node is not GameKey:
|
|
continue
|
|
var game_key := node as GameKey
|
|
var key_props := game_key.props
|
|
var dict_key := Vector2i(key_props.keycode, key_props.location)
|
|
if current_keys.has(dict_key):
|
|
current_keys[dict_key].append(game_key)
|
|
else:
|
|
current_keys[dict_key] = [game_key] as Array[GameKey]
|
|
|
|
_iterate_key_props_rows(_regenerate_key, key_props_rows, current_keys)
|
|
|
|
for game_keys: Array[GameKey] in current_keys.values():
|
|
for game_key in game_keys:
|
|
game_key.queue_free()
|
|
|
|
|
|
func _regenerate_key(
|
|
key_props: KeyProps,
|
|
key_pos: Vector3,
|
|
angle: float,
|
|
current_keys: Dictionary[Vector2i, Array]
|
|
) -> void:
|
|
var dict_key := Vector2i(key_props.keycode, key_props.location)
|
|
|
|
if current_keys.has(dict_key):
|
|
var game_keys := current_keys[dict_key] as Array[GameKey]
|
|
var game_key_idx: int
|
|
var min_dist: float = 0
|
|
for i in range(game_keys.size()):
|
|
var dist := game_keys[i].position.distance_to(key_pos)
|
|
if min_dist == 0 or dist <= min_dist:
|
|
min_dist = dist
|
|
game_key_idx = i
|
|
game_keys[game_key_idx].load_props(key_props, key_pos, angle)
|
|
|
|
game_keys.remove_at(game_key_idx)
|
|
if game_keys.size() == 0:
|
|
current_keys.erase(dict_key)
|
|
else:
|
|
var chars_dict := LayoutConfig.get_key_config_dict(key_props.keycode)
|
|
if chars_dict and chars_dict is Dictionary:
|
|
key_props.chars_from_dict(chars_dict)
|
|
|
|
var game_key := GameKey.instantiate_with_props(
|
|
key_props, key_pos, angle, self, _key_scene
|
|
)
|
|
_keys_holder.add_child(game_key, true)
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region animation
|
|
func _reset_animations() -> void:
|
|
anim_time = 0
|
|
_rot_sod = SecondOrderDynamics.new(_rot_sod_fzr, _default_rot)
|
|
|
|
|
|
func _animate(delta: float) -> void:
|
|
anim_time += delta * _anim_time_scale
|
|
_keys_holder.rotation = _rot_sod.process(delta, _animate_rotation())
|
|
|
|
|
|
func _animate_rotation() -> Vector3:
|
|
var new_rotation := _default_rot
|
|
for pos: Vector3 in pressed_positions.keys():
|
|
var pos_pressed := pressed_positions[pos]
|
|
if not pos_pressed:
|
|
continue
|
|
new_rotation.z -= (pos.x / key_size) * _pressing_lean_rad.x
|
|
new_rotation.x += (pos.z / key_size) * _pressing_lean_rad.y
|
|
|
|
return new_rotation
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region sounds
|
|
func _play_sfx(stream: AudioStream) -> void:
|
|
_polyphonic.play_stream(stream)
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region prompt
|
|
func _set_prompt_pages() -> void:
|
|
prompt_page = 0
|
|
prompt_pages_total = ceili(LayoutConfig.layouts.size() / 9.0)
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region editor
|
|
func _generate_editor_keys() -> void:
|
|
_delete_editor_keys()
|
|
_iterate_key_props_rows(_generate_game_key, LayoutANSI.new().get_key_props_rows())
|
|
|
|
|
|
func _delete_editor_keys() -> void:
|
|
pressed_positions = {}
|
|
var nodes := _keys_holder.get_children()
|
|
if not nodes:
|
|
return
|
|
print("deleting keys...")
|
|
for node in nodes:
|
|
node.queue_free()
|
|
|
|
|
|
func _query_editor_keys() -> void:
|
|
print(query_key_by_keycode(KEY_SHIFT))
|
|
|
|
#endregion
|