Refactor combat transition logic into combat state; add trigger and interaction examples

food-please · food-please · commit e8de3bac4020 · 2024-04-29T23:16:20.000-07:00
diff --git a/assets/music/squashin_bugs_fixed.mp3 b/assets/music/squashin_bugs_fixed.mp3
diff --git a/assets/music/squashin_bugs_fixed.mp3.import b/assets/music/squashin_bugs_fixed.mp3.import
diff --git a/maps/town/conversation_encounter.gd b/maps/town/conversation_encounter.gd
@@ -0,0 +1,37 @@
+@tool
+
+extends Interaction
+
+@export var pre_combat_timeline: DialogicTimeline
+@export var victory_timeline: DialogicTimeline
+@export var loss_timeline: DialogicTimeline
+
+@export var combat_arena: PackedScene
+
+
+func _execute() -> void:
+	Dialogic.start_timeline(pre_combat_timeline)
+	
+	# Wait for the timeline to finish before beginning combat.
+	await Dialogic.timeline_ended
+	
+	# Let other systems know that a combat has been triggered and then wait for its outcome.
+	FieldEvents.combat_triggered.emit(combat_arena)
+	
+	await CombatEvents.combat_finished
+	
+	# The combat ends with a covered screen, and so we fix that here.
+	Transition.clear.call_deferred(0.2)
+	await Transition.finished
+	
+	# We want to run post-combat events. In some cases, this may not involve much, such as playing a
+	# game-over screen or removing an AI combat-starting gamepiece from the field.
+	# In some cases, however, we'll want a dialogue to play or some creative event to occur if, for
+	# example, the player lost a difficult but non-essential battle.
+	if CombatEvents.did_player_win_last_combat:
+		Dialogic.start_timeline(victory_timeline)
+	
+	else:
+		Dialogic.start_timeline(loss_timeline)
+	
+	await Dialogic.timeline_ended
diff --git a/maps/town/encounter_before_combat.dtl b/maps/town/encounter_before_combat.dtl
@@ -0,0 +1,4 @@
+join ghost 1
+ghost: Your father was a hamster and your mother reeked of elderberry!
+ghost: En garde!
+[end_timeline]
diff --git a/maps/town/encounter_on_loss.dtl b/maps/town/encounter_on_loss.dtl
@@ -0,0 +1,3 @@
+join ghost 1
+ghost: Ha! Come on, you pansy!
+[end_timeline]
diff --git a/maps/town/encounter_on_victory.dtl b/maps/town/encounter_on_victory.dtl
@@ -0,0 +1,4 @@
+join ghost 1
+ghost: Ow...
+ghost: Tis but a scratch!
+[end_timeline]
diff --git a/project.godot b/project.godot
@@ -80,6 +80,9 @@ directories/dch_directory={
 "wizard": "res://maps/town/wizard.dch"
 }
 directories/dtl_directory={
+"encounter_before_combat": "res://maps/town/encounter_before_combat.dtl",
+"encounter_on_loss": "res://maps/town/encounter_on_loss.dtl",
+"encounter_on_victory": "res://maps/town/encounter_on_victory.dtl",
 "fan_of_four": "res://maps/town/fan_of_four.dtl",
 "ghost": "res://maps/grove/ghost.dtl",
 "monk": "res://maps/town/monk.dtl",
diff --git a/src/combat/arena_data.gd b/src/combat/arena_data.gd
diff --git a/src/combat/combat.gd b/src/combat/combat.gd
@@ -2,18 +2,36 @@ extends CanvasLayer
 
 var _active_arena: CombatArena = null
 
+# Keep track of what music track was playing previously, and return to it once combat has finished.
+var _previous_music_track: AudioStream = null
+
 @onready var _combat_containter: = $CenterContainer as CenterContainer
 
 
 func _ready() -> void:
-	CombatEvents.combat_initiated.connect(_on_combat_initiated)
-	CombatEvents.combat_finished.connect(_on_combat_finished)
+	FieldEvents.combat_triggered.connect(start)
+	
+	# TODO: remove with _unhandled input once Battlers have been implemented.
+	set_process_unhandled_input(false)
 
 
-func _on_combat_initiated(arena: PackedScene) -> void:
-	# Don't start a new combat if one is currently ongoing.
-	if _active_arena:
-		return
+# TODO: This is included to allow leaving the combat state.
+# In future releases, these signals will be emitted once battlers from one side have fallen.
+func _unhandled_input(event: InputEvent) -> void:
+	if event.is_action_released("back"):
+		CombatEvents.did_player_win_last_combat = false
+		finish()
+	
+	elif event.is_action_released("interact"):
+		CombatEvents.did_player_win_last_combat = true
+		finish()
+
+
+func start(arena: PackedScene) -> void:
+	assert(not _active_arena, "Attempting to start a combat when one is ongoing!")
+	
+	# Cover the screen.
+	await Transition.cover(0.2)
 	
 	# Try to setup the combat arena (which comes with AI battlers, etc.). 
 	var new_arena: = arena.instantiate()
@@ -22,11 +40,39 @@ func _on_combat_initiated(arena: PackedScene) -> void:
 	
 	_active_arena = new_arena
 	_combat_containter.add_child(_active_arena)
+	
+	_previous_music_track = Music.get_playing_track()
+	Music.play(_active_arena.music)
+	
+	# Let other systems know that the combat state is setup and ready to begin.
+	CombatEvents.combat_initiated.emit()
+	
+	# Before starting combat itself, reveal the screen again.
+	# The Transition.clear() call is deferred since it follows on the heels of cover(), and needs a
+	# frame to allow everything else to respond to Transition.finished.
+	Transition.clear.call_deferred(0.2)
+	await Transition.finished
+	
+	# TODO: remove with _unhandled input once Battlers have been implemented.
+	set_process_unhandled_input(true)
 
 
-func _on_combat_finished() -> void:
+func finish() -> void:
+	# TODO: remove with _unhandled input once Battlers have been implemented.
+	set_process_unhandled_input(false)
+	
 	if not _active_arena:
 		return
 	
+	# Cover the screen again, transitioning away from the combat game state.
+	await Transition.cover(0.2)
+	
 	_active_arena.queue_free()
 	_active_arena = null
+	
+	# Signal that the combat has been finished and all combat objects have been dealt with
+	# accordingly. The field game 'state' will now be in focus.
+	# Note that whatever object started the combat will now be responsible for flow of the game. In
+	# particular, the screen is still covered, so the combat-starting object will want to decide
+	# what to do now that the outcome of the combat is known.
+	CombatEvents.combat_finished.emit()
diff --git a/src/combat/combat_arena.gd b/src/combat/combat_arena.gd
@@ -1,13 +1,3 @@
 class_name CombatArena extends Control
 
 @export var music: AudioStream
-
-
-# TODO: This is included to allow leaving the combat state.
-# In future releases, these signals will be emitted once battlers from one side have fallen.
-func _unhandled_input(event: InputEvent) -> void:
-	if event.is_action_released("back"):
-		CombatEvents.combat_lost.emit()
-	
-	elif event.is_action_released("interact"):
-		CombatEvents.combat_won.emit()
diff --git a/src/common/combat_events.gd b/src/common/combat_events.gd
@@ -1,19 +1,16 @@
 ## A signal bus to connect distant scenes to various combat-exclusive events.
 extends Node
 
-## Emitted whenever a combat is triggered. Technically, this event occurs within the field state.
+## Emitted whenever a combat has been setup and is ready to become the active 'game state'. At this
+## point, the screen is fully covered by the [ScreenTransition] autoload.
 signal combat_initiated(arena: PackedScene)
 
-## Emitted immediately after the player has won combat and all animations have finished. Also, the
-## the battle results screen has been displayed and dismissed.
-## This is used to fade the screen post-combat and notify the combat-starting-trigger of the result.
-signal combat_won
-
-## Emitted immediately after the player has lost combat and all animations have finished.
-## This is used to fade the screen post-combat and notify the combat-starting-trigger of the result.
-signal combat_lost
-
 ## Emitted whenever the player has finished with the combat state regardless of whether or not the
 ## combat was won by the player. At this point the screen has faded to black and any events that
 ## immediately follow the combat may occur.
-signal combat_finished
+signal combat_finished(is_player_victory: bool)
+
+
+## A variable that allows objects to know if the player won the most recent combat. This should only
+## be accessed, and is designed to be set by the combat state.
+var did_player_win_last_combat: = false
diff --git a/src/common/field_events.gd b/src/common/field_events.gd
@@ -11,6 +11,10 @@ signal cell_highlighted(cell: Vector2i)
 ## Emitted when the player selects a cell on the field gameboard via the [FieldCursor].
 signal cell_selected(cell: Vector2i)
 
+## Emitted whenever a combat is triggered. This will lead to a transition from the field 'state' to
+## a combat 'state'.
+signal combat_triggered(arena: PackedScene)
+
 ## Emitted when a [Cutscene] begins, signalling that the player should yield control of their
 ## character to the cutscene code.
 signal cutscene_began
diff --git a/src/common/music/music_player.gd b/src/common/music/music_player.gd
@@ -40,7 +40,12 @@ func stop(time_out: = 0.0) -> void:
 	await _anim.animation_finished
 	
 	_track.stop()
+	_track.stream = null
 
 
 func is_playing() -> bool:
 	return _track.playing
+
+
+func get_playing_track() -> AudioStream:
+	return _track.stream
diff --git a/src/common/screen_transitions/screen_transition.gd b/src/common/screen_transitions/screen_transition.gd
@@ -64,9 +64,11 @@ func clear(duration: = 0.0) -> void:
 ## This method is a coroutine that will finish once the screen has been covered.
 func cover(duration: = 0.0) -> void:
 	if _tween:
+		if _tween.is_running():
+			finished.emit()
 		_tween.kill()
 		_tween = null
-		finished.emit()
+		
 
 	if is_equal_approx(duration, 0.0) or _color_rect.modulate.is_equal_approx(COVERED):
 		_color_rect.modulate = COVERED
@@ -82,4 +84,4 @@ func cover(duration: = 0.0) -> void:
 func _tween_transition(duration: float, target_colour: Color) -> void:
 	_tween = create_tween()
 	_tween.tween_property(_color_rect, "modulate", target_colour, duration)
-	_tween.tween_callback(func(): finished.emit())
+	_tween.tween_callback(func(): emit_signal.call_deferred("finished"))
diff --git a/src/field/cutscenes/templates/combat/combat_trigger.gd b/src/field/cutscenes/templates/combat/combat_trigger.gd
@@ -1,87 +1,30 @@
 @tool
 class_name CombatTrigger extends Trigger
 
-# The following signal is emitted as soon as the combat results are known. That is, the player has
-# either lost and their battlers are now free OR the player has won and the combat results screen
-# has already been closed.
-# The trigger responds to this signal by running a screen transition.
-signal _combat_resolved
-
 @export var combat_arena: PackedScene
 
-# An internal flag that tracks the outcome of a given combat instance. It is reset every time this
-# trigger is run.
-var _is_victory: = false
-
 
 func _execute() -> void:
-	# Cover the screen.
-	await Transition.cover(0.2)
+	# Let other systems know that a combat has been triggered and then wait for its outcome.
+	FieldEvents.combat_triggered.emit(combat_arena)
 	
-	# The screen is black, so let all systems know that it's time to setup the combat scene.
-	CombatEvents.combat_initiated.emit(combat_arena)
+	await CombatEvents.combat_finished
 	
-	# The trigger wants to know if the player wins or loses combat, so we'll listen in for win/lose
-	# signals. We only want the trigger to know about THIS combat, so we need to track the method
-	# reference in order to disconnect it, since the callback will not be called on a loss.
-	_is_victory = false
-	CombatEvents.combat_won.connect(_on_combat_won)
-	CombatEvents.combat_lost.connect(_on_combat_lost)
-	
-	# Before starting combat itself, reveal the screen again.
-	# The Transition.clear() call is deferred since it follows on the heels of cover(), and needs a
-	# frame to allow everything else to respond to Transition.finished.
-	Transition.clear.call_deferred(0.2)
-	await Transition.finished
-	
-	# Wait for combat to wrap up before continuing the trigger.
-	await self._combat_resolved
-	
-	# Combat is finished, so we want to cover the screen again before re-starting the field scene.
-	CombatEvents.combat_won.disconnect(_on_combat_won)
-	CombatEvents.combat_lost.disconnect(_on_combat_lost)
-	
-	# Cover the screen again, transitioning away from the combat game state.
-	await Transition.cover(0.2)
-	
-	# Now that the screen has been covered, let other systems know that the combat is over. This
-	# will free up the combat arena, un-hide the field state, etc.
-	# The Transition.clear() call is deferred since it follows on the heels of cover(), and needs a
-	# frame to allow everything else to respond to Transition.finished.
-	CombatEvents.combat_finished.emit()
+	# The combat ends with a covered screen, and so we fix that here.
 	Transition.clear.call_deferred(0.2)
 	await Transition.finished
 	
 	# We want to run post-combat events. In some cases, this may not involve much, such as playing a
 	# game-over screen or removing an AI combat-starting gamepiece from the field.
 	# In some cases, however, we'll want a dialogue to play or some creative event to occur if, for
 	# example, the player lost a difficult but non-essential battle.
-	if _is_victory:
+	if CombatEvents.did_player_win_last_combat:
 		await _run_victory_cutscene()
 	
 	else:
 		await _run_loss_cutscene() 
 
 
-# The following method is called once the player has won combat and dismissed the results screen.
-# This hands control back to this trigger, which may then cover the screen and transition back to
-# the field.
-# Note that this is not merely a lambda since we only want this callback to respond to the combat of
-# this particular trigger and, therefore, must be reconnected/disconnected as the trigger is run.
-func _on_combat_won() -> void:
-	_is_victory = true
-	_combat_resolved.emit()
-
-
-# The following method is called once the player has lost combat and animations have finished.
-# This hands control back to this trigger, which may then cover the screen and transition back to
-# the field or the gameover screen.
-# Note that this is not merely a lambda since we only want this callback to respond to the combat of
-# this particular trigger and, therefore, must be reconnected/disconnected as the trigger is run.
-func _on_combat_lost() -> void:
-	_combat_resolved.emit()
-
-
 ## The following method may be overwridden to allow for custom behaviour following a combat victory.
 ## Examples include adding an item to the player's inventory, running a dialogue, removing an enemy
 ## [Gamepiece], etc.
diff --git a/src/field/field.gd b/src/field/field.gd
@@ -17,7 +17,7 @@ func _ready() -> void:
 	# The field state must pause/unpause with combat accordingly.
 	# Note that pausing/unpausing input is already wrapped up in triggers, which are what will
 	# initiate combat.
-	CombatEvents.combat_initiated.connect(func(_arena): hide())
+	CombatEvents.combat_initiated.connect(func(): hide())
 	CombatEvents.combat_finished.connect(func(): show())
 	
 	Camera.scale = scale
diff --git a/src/main.tscn b/src/main.tscn

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+join ghost 1`
	`2`	`+ghost: Ha! Come on, you pansy!`
	`3`	`+[end_timeline]`