Add combat combo gameplay
This commit is contained in:
wxm
@@ -1,23 +1,106 @@
|
||||
class_name Player
|
||||
extends Character
|
||||
|
||||
signal combo_window_changed(slots: Array)
|
||||
signal combo_window_cleared(reason: String)
|
||||
signal charge_changed(current: float, maximum: float, ready: bool, active: bool)
|
||||
signal energy_changed(current: int, maximum: int)
|
||||
signal health_changed(current: int, maximum: int)
|
||||
signal skill_requested(skill_id: String)
|
||||
|
||||
@export var combo_clear_display_time := 0.35
|
||||
@export var charge_duration := 1.1
|
||||
@export var max_health := 100
|
||||
@export var current_health := 100
|
||||
@export var max_energy := 10
|
||||
@export var current_energy := 0
|
||||
|
||||
var combo_window := ComboWindow.new()
|
||||
var last_requested_skill_id := ""
|
||||
var current_skill_animation := ""
|
||||
var combo_clear_timer: Timer
|
||||
var charge_value := 0.0
|
||||
var charge_ready := false
|
||||
var charge_active := false
|
||||
var _pending_combo_clear_reason := ""
|
||||
var _charge_effect_time := 0.0
|
||||
var _charge_hold_symbol := ""
|
||||
var _charge_hold_direction := Vector2.ZERO
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
combo_clear_timer = Timer.new()
|
||||
combo_clear_timer.one_shot = true
|
||||
combo_clear_timer.wait_time = combo_clear_display_time
|
||||
combo_clear_timer.timeout.connect(flush_pending_combo_clear)
|
||||
add_child(combo_clear_timer)
|
||||
combo_window.window_cleared.connect(_on_combo_window_cleared)
|
||||
_emit_combo_window_changed()
|
||||
_emit_charge_changed()
|
||||
_emit_health_changed()
|
||||
_emit_energy_changed()
|
||||
|
||||
|
||||
func _process(delta: float) -> void:
|
||||
_update_charge(delta)
|
||||
|
||||
|
||||
func _input(event: InputEvent) -> void:
|
||||
if _handle_combo_key_event(event):
|
||||
_mark_input_handled()
|
||||
|
||||
|
||||
func _unhandled_input(event: InputEvent) -> void:
|
||||
if _handle_combo_key_event(event):
|
||||
_mark_input_handled()
|
||||
|
||||
|
||||
func _handle_combo_key_event(event: InputEvent) -> bool:
|
||||
var key_event := event as InputEventKey
|
||||
if key_event == null or key_event.echo:
|
||||
return false
|
||||
if not key_event.pressed:
|
||||
if _event_matches_key(key_event, KEY_A):
|
||||
_finish_charge_hold("A")
|
||||
return true
|
||||
elif _event_matches_key(key_event, KEY_D):
|
||||
_finish_charge_hold("D")
|
||||
return true
|
||||
return false
|
||||
if _event_matches_key(key_event, KEY_W):
|
||||
_submit_combo_input_from_event("W")
|
||||
return true
|
||||
elif _event_matches_key(key_event, KEY_A):
|
||||
heading = Vector2.LEFT
|
||||
var skill_id := _submit_combo_input_from_event("A")
|
||||
if skill_id == "skill_a":
|
||||
_begin_charge_hold("A", Vector2.LEFT)
|
||||
return true
|
||||
elif _event_matches_key(key_event, KEY_D):
|
||||
heading = Vector2.RIGHT
|
||||
var skill_id := _submit_combo_input_from_event("D")
|
||||
if skill_id == "skill_d":
|
||||
_begin_charge_hold("D", Vector2.RIGHT)
|
||||
return true
|
||||
elif _event_matches_key(key_event, KEY_S):
|
||||
_submit_combo_input_from_event("S")
|
||||
return true
|
||||
elif _event_matches_key(key_event, KEY_SPACE):
|
||||
_submit_combo_input_from_event("SP")
|
||||
return true
|
||||
return false
|
||||
|
||||
|
||||
func handle_input() -> void:
|
||||
if Input.is_action_just_pressed("ui_left"):
|
||||
judge_rhythm_action("left")
|
||||
if can_attack():
|
||||
start_directional_attack(Vector2.LEFT)
|
||||
return
|
||||
if Input.is_action_just_pressed("ui_right"):
|
||||
judge_rhythm_action("right")
|
||||
if can_attack():
|
||||
start_directional_attack(Vector2.RIGHT)
|
||||
if charge_active:
|
||||
velocity = Vector2.ZERO
|
||||
return
|
||||
_apply_horizontal_movement()
|
||||
if Input.is_action_just_pressed("jump"):
|
||||
judge_rhythm_action("jump")
|
||||
if can_jump():
|
||||
start_jump()
|
||||
if state == State.IDLE or state == State.WALK:
|
||||
velocity.x = 0.0
|
||||
|
||||
|
||||
func set_heading() -> void:
|
||||
if velocity.x > 0.0:
|
||||
@@ -25,7 +108,407 @@ func set_heading() -> void:
|
||||
elif velocity.x < 0.0:
|
||||
heading = Vector2.LEFT
|
||||
|
||||
func judge_rhythm_action(action_name: String) -> void:
|
||||
|
||||
func get_combo_slots() -> Array[String]:
|
||||
return combo_window.get_slots()
|
||||
|
||||
|
||||
func get_energy() -> int:
|
||||
return current_energy
|
||||
|
||||
|
||||
func get_max_energy() -> int:
|
||||
return max_energy
|
||||
|
||||
|
||||
func get_health() -> int:
|
||||
return current_health
|
||||
|
||||
|
||||
func get_max_health() -> int:
|
||||
return max_health
|
||||
|
||||
|
||||
func get_charge() -> float:
|
||||
return charge_value
|
||||
|
||||
|
||||
func get_max_charge() -> float:
|
||||
return charge_duration
|
||||
|
||||
|
||||
func is_charge_active() -> bool:
|
||||
return charge_active
|
||||
|
||||
|
||||
func is_charge_ready() -> bool:
|
||||
return charge_ready
|
||||
|
||||
|
||||
func submit_combo_input(symbol: String, forced_rating := "") -> String:
|
||||
match symbol:
|
||||
"W":
|
||||
return _record_combo_symbol("W", "w", forced_rating)
|
||||
"A":
|
||||
return _record_combo_symbol("A", "a", forced_rating)
|
||||
"D":
|
||||
return _record_combo_symbol("D", "d", forced_rating)
|
||||
"S":
|
||||
return _record_combo_symbol("S", "s", forced_rating)
|
||||
"SP":
|
||||
return _record_combo_symbol("SP", "space", forced_rating)
|
||||
return ""
|
||||
|
||||
|
||||
func _record_combo_symbol(symbol: String, rhythm_action: String, forced_rating := "") -> String:
|
||||
var rating := _rating_or_forced(judge_rhythm_action(rhythm_action), forced_rating)
|
||||
_apply_energy_reward(str(rating.get("label", "perfect")))
|
||||
if not _record_rated_combo_input(symbol, rating):
|
||||
if symbol == "A" or symbol == "D":
|
||||
_cancel_missed_direction_action()
|
||||
return ""
|
||||
var resolved := InputResolver.resolve(combo_window)
|
||||
if resolved.is_empty() and _pending_combo_clear_reason == "full":
|
||||
resolved = _resolve_full_window_fallback(symbol)
|
||||
if not resolved.is_empty():
|
||||
if not _execute_combo_skill(resolved):
|
||||
return ""
|
||||
if symbol == "SP" and not _is_projectile_space_chain() and _pending_combo_clear_reason.is_empty():
|
||||
_schedule_combo_clear("space")
|
||||
return last_requested_skill_id if not resolved.is_empty() else ""
|
||||
|
||||
|
||||
func _submit_combo_input_from_event(symbol: String) -> String:
|
||||
return submit_combo_input(symbol)
|
||||
|
||||
|
||||
func _event_matches_key(event: InputEventKey, key: Key) -> bool:
|
||||
return event.physical_keycode == key or event.keycode == key
|
||||
|
||||
|
||||
func _event_matches_any_key(event: InputEventKey, keys: Array[Key]) -> bool:
|
||||
for key: Key in keys:
|
||||
if _event_matches_key(event, key):
|
||||
return true
|
||||
return false
|
||||
|
||||
|
||||
func _mark_input_handled() -> void:
|
||||
var viewport := get_viewport()
|
||||
if viewport != null:
|
||||
viewport.set_input_as_handled()
|
||||
|
||||
|
||||
func _record_combo_direction(symbol: String, direction: Vector2, rhythm_action: String, forced_rating := "") -> void:
|
||||
heading = direction
|
||||
var rating := _rating_or_forced(judge_rhythm_action(rhythm_action), forced_rating)
|
||||
_record_rated_combo_input(symbol, rating)
|
||||
if state == State.IDLE or state == State.WALK:
|
||||
velocity.x = 0.0
|
||||
|
||||
|
||||
func _record_rated_combo_input(symbol: String, rating: Dictionary) -> bool:
|
||||
if str(rating.get("label", "perfect")) == "miss":
|
||||
_record_combo_input("Ø")
|
||||
return false
|
||||
_record_combo_input(symbol)
|
||||
return true
|
||||
|
||||
|
||||
func _record_combo_input(symbol: String) -> void:
|
||||
if combo_window.has_pending_clear() or not _pending_combo_clear_reason.is_empty():
|
||||
if _pending_combo_clear_reason.begins_with("skill:") and not combo_window.has_pending_clear():
|
||||
_cancel_pending_combo_clear()
|
||||
else:
|
||||
flush_pending_combo_clear()
|
||||
combo_window.record(symbol)
|
||||
_emit_combo_window_changed()
|
||||
var reason := combo_window.consume_pending_clear_reason()
|
||||
if not reason.is_empty():
|
||||
_schedule_combo_clear(reason)
|
||||
|
||||
|
||||
func _rating_or_forced(rating: Dictionary, forced_rating: String) -> Dictionary:
|
||||
if forced_rating.is_empty():
|
||||
return rating
|
||||
var forced := rating.duplicate()
|
||||
forced["label"] = forced_rating
|
||||
return forced
|
||||
|
||||
|
||||
func _execute_combo_skill(skill: Dictionary) -> bool:
|
||||
if not _spend_skill_energy(skill):
|
||||
return false
|
||||
last_requested_skill_id = str(skill.get("id", ""))
|
||||
current_skill_animation = str(skill.get("animation", "warrior_idle"))
|
||||
skill_requested.emit(last_requested_skill_id)
|
||||
judge_rhythm_action(last_requested_skill_id)
|
||||
_play_skill_animation(current_skill_animation, _skill_displacement_direction(skill))
|
||||
if bool(skill.get("projectile", false)):
|
||||
_fire_projectile()
|
||||
_emit_combo_window_changed()
|
||||
if bool(skill.get("clear_window", false)):
|
||||
_schedule_combo_clear("skill:%s" % last_requested_skill_id)
|
||||
return true
|
||||
|
||||
|
||||
func _play_skill_animation(animation_name: String, displacement_direction := Vector2.ZERO) -> void:
|
||||
var player_animation := _get_animation_player()
|
||||
anim_map[State.ATTACK] = animation_name
|
||||
state = State.ATTACK
|
||||
attack_time_left = _animation_length(animation_name)
|
||||
if displacement_direction == Vector2.ZERO:
|
||||
attack_lunge_time_left = 0.0
|
||||
velocity = Vector2.ZERO
|
||||
else:
|
||||
heading = displacement_direction
|
||||
attack_lunge_time_left = attack_lunge_duration
|
||||
velocity = Vector2(displacement_direction.x * attack_lunge_speed, 0.0)
|
||||
if player_animation != null and player_animation.has_animation(animation_name):
|
||||
player_animation.play(animation_name)
|
||||
|
||||
|
||||
func _skill_displacement_direction(skill: Dictionary) -> Vector2:
|
||||
match str(skill.get("displacement", "")):
|
||||
"left":
|
||||
return Vector2.LEFT
|
||||
"right":
|
||||
return Vector2.RIGHT
|
||||
return Vector2.ZERO
|
||||
|
||||
|
||||
func _apply_energy_reward(rating_label: String) -> void:
|
||||
match rating_label:
|
||||
"perfect":
|
||||
_change_energy(2)
|
||||
"good":
|
||||
_change_energy(1)
|
||||
|
||||
|
||||
func _spend_skill_energy(skill: Dictionary) -> bool:
|
||||
var energy_cost := int(skill.get("energy_cost", 0))
|
||||
if energy_cost <= 0:
|
||||
return true
|
||||
if current_energy < energy_cost:
|
||||
return false
|
||||
_change_energy(-energy_cost)
|
||||
return true
|
||||
|
||||
|
||||
func _change_energy(delta: int) -> void:
|
||||
var next_energy := clampi(current_energy + delta, 0, max_energy)
|
||||
if next_energy == current_energy:
|
||||
return
|
||||
current_energy = next_energy
|
||||
_emit_energy_changed()
|
||||
|
||||
|
||||
func _begin_charge_hold(symbol: String, direction: Vector2) -> void:
|
||||
_charge_hold_symbol = symbol
|
||||
_charge_hold_direction = direction
|
||||
|
||||
|
||||
func _finish_charge_hold(symbol: String) -> void:
|
||||
if _charge_hold_symbol != symbol:
|
||||
return
|
||||
var release_ready := charge_active and charge_ready
|
||||
var release_direction := _charge_hold_direction
|
||||
var release_skill := "skill_a_charge_release" if symbol == "A" else "skill_d_charge_release"
|
||||
_cancel_charge()
|
||||
if release_ready:
|
||||
_execute_charge_release(release_skill, release_direction)
|
||||
|
||||
|
||||
func _update_charge(delta: float) -> void:
|
||||
if _charge_hold_symbol.is_empty():
|
||||
return
|
||||
if not charge_active:
|
||||
if state != State.IDLE:
|
||||
return
|
||||
_start_charge()
|
||||
if not charge_active:
|
||||
return
|
||||
state = State.IDLE
|
||||
attack_time_left = 0.0
|
||||
attack_lunge_time_left = 0.0
|
||||
velocity = Vector2.ZERO
|
||||
var player_animation := _get_animation_player()
|
||||
if player_animation != null and player_animation.has_animation("warrior_idle") and player_animation.current_animation != "warrior_idle":
|
||||
player_animation.play("warrior_idle")
|
||||
charge_value = minf(charge_duration, charge_value + delta)
|
||||
charge_ready = charge_value >= charge_duration
|
||||
_update_charge_effect(delta)
|
||||
_emit_charge_changed()
|
||||
|
||||
|
||||
func _start_charge() -> void:
|
||||
charge_active = true
|
||||
charge_value = 0.0
|
||||
charge_ready = false
|
||||
_charge_effect_time = 0.0
|
||||
_update_charge_effect(0.0)
|
||||
_emit_charge_changed()
|
||||
|
||||
|
||||
func _cancel_charge() -> void:
|
||||
_charge_hold_symbol = ""
|
||||
_charge_hold_direction = Vector2.ZERO
|
||||
charge_active = false
|
||||
charge_value = 0.0
|
||||
charge_ready = false
|
||||
_set_charge_effect_visible(false)
|
||||
_emit_charge_changed()
|
||||
|
||||
|
||||
func _execute_charge_release(skill_id: String, direction: Vector2) -> void:
|
||||
last_requested_skill_id = skill_id
|
||||
current_skill_animation = "warrior_charge_release"
|
||||
skill_requested.emit(last_requested_skill_id)
|
||||
_play_skill_animation(current_skill_animation, direction)
|
||||
|
||||
|
||||
func _update_charge_effect(delta: float) -> void:
|
||||
var sprite := _get_charge_effect_sprite()
|
||||
if sprite == null:
|
||||
return
|
||||
sprite.visible = charge_active
|
||||
if not charge_active:
|
||||
return
|
||||
_charge_effect_time += delta
|
||||
sprite.frame = int(_charge_effect_time * 12.0) % 5
|
||||
|
||||
|
||||
func _set_charge_effect_visible(is_visible: bool) -> void:
|
||||
var sprite := _get_charge_effect_sprite()
|
||||
if sprite != null:
|
||||
sprite.visible = is_visible
|
||||
|
||||
|
||||
func _get_charge_effect_sprite() -> Sprite2D:
|
||||
if has_node("ChargeEffectSprite"):
|
||||
return get_node("ChargeEffectSprite") as Sprite2D
|
||||
return null
|
||||
|
||||
|
||||
func _resolve_full_window_fallback(symbol: String) -> Dictionary:
|
||||
if symbol != "A" and symbol != "D":
|
||||
return {}
|
||||
return InputResolver.resolve_pattern(symbol)
|
||||
|
||||
|
||||
func _cancel_missed_direction_action() -> void:
|
||||
velocity = Vector2.ZERO
|
||||
attack_lunge_time_left = 0.0
|
||||
attack_time_left = 0.0
|
||||
state = State.IDLE
|
||||
anim_map[State.ATTACK] = "warrior_a"
|
||||
var player_animation := _get_animation_player()
|
||||
if player_animation != null and player_animation.has_animation("warrior_idle"):
|
||||
player_animation.play("warrior_idle")
|
||||
|
||||
|
||||
func _is_projectile_space_chain() -> bool:
|
||||
var pattern := combo_window.get_contiguous_pattern()
|
||||
return pattern == "SSP" or pattern == "SSPSP" or pattern == "SSPSPSP"
|
||||
|
||||
|
||||
func _apply_horizontal_movement() -> void:
|
||||
if charge_active:
|
||||
velocity.x = 0.0
|
||||
return
|
||||
if state != State.IDLE and state != State.WALK:
|
||||
return
|
||||
var direction := 0.0
|
||||
if Input.is_action_pressed("player_a"):
|
||||
direction -= 1.0
|
||||
if Input.is_action_pressed("player_d"):
|
||||
direction += 1.0
|
||||
if direction < 0.0:
|
||||
heading = Vector2.LEFT
|
||||
elif direction > 0.0:
|
||||
heading = Vector2.RIGHT
|
||||
velocity.x = direction * speed
|
||||
|
||||
|
||||
func _animation_length(animation_name: String) -> float:
|
||||
var player_animation := _get_animation_player()
|
||||
if player_animation != null and player_animation.has_animation(animation_name):
|
||||
return maxf(0.1, player_animation.get_animation(animation_name).length)
|
||||
return attack_duration
|
||||
|
||||
|
||||
func _get_animation_player() -> AnimationPlayer:
|
||||
if animation_player == null and has_node("AnimationPlayer"):
|
||||
animation_player = get_node("AnimationPlayer") as AnimationPlayer
|
||||
return animation_player
|
||||
|
||||
|
||||
func _fire_projectile() -> void:
|
||||
var projectile := PlayerProjectile.new()
|
||||
projectile.direction = heading
|
||||
projectile.global_position = global_position + Vector2(heading.x * 36.0, -30.0)
|
||||
var parent := get_parent()
|
||||
if parent != null:
|
||||
parent.add_child(projectile)
|
||||
else:
|
||||
add_child(projectile)
|
||||
projectile.add_to_group("player_projectiles")
|
||||
|
||||
|
||||
func _cancel_pending_combo_clear() -> void:
|
||||
_pending_combo_clear_reason = ""
|
||||
if combo_clear_timer != null:
|
||||
combo_clear_timer.stop()
|
||||
|
||||
|
||||
func _schedule_combo_clear(reason: String) -> void:
|
||||
_pending_combo_clear_reason = reason
|
||||
if combo_clear_timer == null:
|
||||
return
|
||||
combo_clear_timer.stop()
|
||||
combo_clear_timer.wait_time = combo_clear_display_time
|
||||
combo_clear_timer.start()
|
||||
|
||||
|
||||
func flush_pending_combo_clear() -> void:
|
||||
var reason := _pending_combo_clear_reason
|
||||
if reason.is_empty():
|
||||
reason = combo_window.consume_pending_clear_reason()
|
||||
else:
|
||||
combo_window.consume_pending_clear_reason()
|
||||
if reason.is_empty():
|
||||
return
|
||||
_pending_combo_clear_reason = ""
|
||||
if combo_clear_timer != null:
|
||||
combo_clear_timer.stop()
|
||||
combo_window.clear(reason)
|
||||
|
||||
|
||||
func _on_combo_window_cleared(reason: String) -> void:
|
||||
combo_window_cleared.emit(reason)
|
||||
_emit_combo_window_changed()
|
||||
|
||||
|
||||
func _emit_combo_window_changed() -> void:
|
||||
combo_window_changed.emit(combo_window.get_slots())
|
||||
|
||||
|
||||
func _emit_charge_changed() -> void:
|
||||
charge_changed.emit(charge_value, charge_duration, charge_ready, charge_active)
|
||||
|
||||
|
||||
func _emit_energy_changed() -> void:
|
||||
energy_changed.emit(current_energy, max_energy)
|
||||
|
||||
|
||||
func _emit_health_changed() -> void:
|
||||
health_changed.emit(current_health, max_health)
|
||||
|
||||
|
||||
func judge_rhythm_action(action_name: String) -> Dictionary:
|
||||
if not is_inside_tree():
|
||||
return {"label": "perfect"}
|
||||
var conductor: Node = get_tree().get_first_node_in_group("rhythm_conductor")
|
||||
if conductor != null and conductor.has_method("judge_action"):
|
||||
conductor.call("judge_action", action_name)
|
||||
return conductor.call("judge_action", action_name) as Dictionary
|
||||
return {"label": "perfect"}
|
||||
|
||||
Reference in New Issue
Block a user