Added Glitch Room Source code to Gitty

core/scenarios/scenario_assignment.gd

@@ -0,0 +1,21 @@
+@tool
+class_name ScenarioAssignment
+extends Resource
+
+
+@export var cabinet: CabinetProfile
+@export var game: GameDefinition
+
+@export var variant: StringName = &"standard"
+
+@export var event_mappings: Array[ScenarioEventMapping] = []
+
+
+func get_actions_for_event(event_name: StringName) -> Array[StringName]:
+	var result: Array[StringName] = []
+
+	for mapping in event_mappings:
+		if mapping.game_event == event_name:
+			result.append_array(mapping.hardware_actions)
+
+	return result

core/scenarios/scenario_assignment.gd.uid

@@ -0,0 +1 @@
+uid://ibujr0ervhhq

core/scenarios/scenario_definition.gd

@@ -0,0 +1,24 @@
+@tool
+class_name ScenarioDefinition
+extends Resource
+
+
+@export var scenario_id: StringName = &""
+@export var display_name: String = ""
+@export var version: int = 1
+
+@export var assignments: Array[ScenarioAssignment] = []
+
+
+func get_assignment_for_cabinet(
+	cabinet_id: StringName
+) -> ScenarioAssignment:
+
+	for assignment in assignments:
+		if assignment.cabinet == null:
+			continue
+
+		if assignment.cabinet.cabinet_id == cabinet_id:
+			return assignment
+
+	return null

core/scenarios/scenario_definition.gd.uid

@@ -0,0 +1 @@
+uid://d3pt6qa05kcnl

core/scenarios/scenario_edit_session.gd

@@ -0,0 +1,318 @@
+class_name ScenarioEditSession
+extends RefCounted
+
+
+signal scenario_changed(
+	scenario: ScenarioDefinition
+)
+
+signal dirty_changed(
+	is_dirty: bool
+)
+
+signal saved
+signal reverted
+
+
+var source_scenario: ScenarioDefinition
+var working_scenario: ScenarioDefinition
+
+var is_dirty: bool = false
+
+var saved_state: Dictionary = {}
+
+func begin(
+	scenario: ScenarioDefinition
+) -> bool:
+
+	if scenario == null:
+		push_error(
+			"ScenarioEditSession cannot begin with a null scenario."
+		)
+		return false
+
+	source_scenario = scenario
+
+	_create_working_copy()
+
+	return true
+	
+
+func mark_dirty() -> void:
+
+	if working_scenario == null:
+		_set_dirty(
+			false
+		)
+		return
+
+	var current_state := (
+		_capture_scenario_state(
+			working_scenario
+		)
+	)
+
+	_set_dirty(
+		current_state != saved_state
+	)
+
+func save() -> bool:
+	if source_scenario == null:
+		push_error(
+			"ScenarioEditSession has no source scenario."
+		)
+		return false
+
+	if working_scenario == null:
+		push_error(
+			"ScenarioEditSession has no working scenario."
+		)
+		return false
+
+	_apply_working_copy_to_source()
+
+	var path := source_scenario.resource_path
+
+	if path.is_empty():
+		push_error(
+			"Source ScenarioDefinition has no resource path."
+		)
+		return false
+
+	var error := ResourceSaver.save(
+		source_scenario,
+		path
+	)
+
+	if error != OK:
+		push_error(
+			"Failed to save ScenarioDefinition. Error: %s"
+			% error
+		)
+		return false
+
+	saved_state = (
+		_capture_scenario_state(
+			working_scenario
+		)
+	)
+
+	_set_dirty(
+		false
+	)
+
+	saved.emit()
+
+	return true
+
+
+func revert() -> void:
+
+	if source_scenario == null:
+		return
+
+	_create_working_copy()
+
+	reverted.emit()
+
+	print(
+		"[SCENARIO EDITOR] Reverted unsaved changes."
+	)
+
+
+func _create_working_copy() -> void:
+
+	var copy := ScenarioDefinition.new()
+
+	copy.scenario_id = source_scenario.scenario_id
+	copy.display_name = source_scenario.display_name
+	copy.version = source_scenario.version
+
+	for source_assignment in source_scenario.assignments:
+
+		if source_assignment == null:
+			continue
+
+		var assignment := (
+			ScenarioAssignment.new()
+		)
+
+		#
+		# Preserve references to the actual
+		# game/cabinet definitions.
+		#
+		assignment.cabinet = (
+			source_assignment.cabinet
+		)
+
+		assignment.game = (
+			source_assignment.game
+		)
+
+		assignment.variant = (
+			source_assignment.variant
+		)
+
+		assignment.event_mappings = (
+			_duplicate_mappings(
+				source_assignment.event_mappings
+			)
+		)
+
+		copy.assignments.append(
+			assignment
+		)
+
+	working_scenario = copy
+
+	#
+	# This working copy is now our clean,
+	# saved baseline.
+	#
+	saved_state = (
+		_capture_scenario_state(
+			working_scenario
+		)
+	)
+
+	_set_dirty(
+		false
+	)
+
+	scenario_changed.emit(
+		working_scenario
+	)
+
+func _duplicate_mappings(
+	source_mappings: Array[ScenarioEventMapping]
+) -> Array[ScenarioEventMapping]:
+
+	var result: Array[ScenarioEventMapping] = []
+
+	for source_mapping in source_mappings:
+		if source_mapping == null:
+			continue
+
+		var mapping := ScenarioEventMapping.new()
+
+		mapping.game_event = (
+			source_mapping.game_event
+		)
+
+		mapping.hardware_actions = (
+			source_mapping.hardware_actions.duplicate()
+		)
+
+		result.append(mapping)
+
+	return result
+
+
+func _apply_working_copy_to_source() -> void:
+	for working_assignment in working_scenario.assignments:
+		if working_assignment == null:
+			continue
+
+		if working_assignment.cabinet == null:
+			continue
+
+		var source_assignment := (
+			source_scenario.get_assignment_for_cabinet(
+				working_assignment.cabinet.cabinet_id
+			)
+		)
+
+		if source_assignment == null:
+			continue
+
+		source_assignment.event_mappings = (
+			_duplicate_mappings(
+				working_assignment.event_mappings
+			)
+		)
+
+func _capture_scenario_state(
+	scenario: ScenarioDefinition
+) -> Dictionary:
+
+	if scenario == null:
+		return {}
+
+	var state := {
+		"scenario_id": scenario.scenario_id,
+		"display_name": scenario.display_name,
+		"version": scenario.version,
+		"assignments": [],
+	}
+
+	for assignment in scenario.assignments:
+
+		if assignment == null:
+			state["assignments"].append(
+				null
+			)
+			continue
+
+		var assignment_state := {
+			"cabinet_id": StringName(),
+			"game_id": StringName(),
+			"variant": assignment.variant,
+			"event_mappings": [],
+		}
+
+		if assignment.cabinet != null:
+			assignment_state["cabinet_id"] = (
+				assignment.cabinet.cabinet_id
+			)
+
+		if assignment.game != null:
+			assignment_state["game_id"] = (
+				assignment.game.game_id
+			)
+
+		for mapping in assignment.event_mappings:
+
+			if mapping == null:
+				assignment_state[
+					"event_mappings"
+				].append(
+					null
+				)
+				continue
+
+			var mapping_state := {
+				"game_event": mapping.game_event,
+				"hardware_actions": [],
+			}
+
+			for action_id in mapping.hardware_actions:
+				mapping_state[
+					"hardware_actions"
+				].append(
+					action_id
+				)
+
+			assignment_state[
+				"event_mappings"
+			].append(
+				mapping_state
+			)
+
+		state["assignments"].append(
+			assignment_state
+		)
+
+	return state
+
+func _set_dirty(
+	value: bool
+) -> void:
+
+	if is_dirty == value:
+		return
+
+	is_dirty = value
+
+	dirty_changed.emit(
+		is_dirty
+	)

core/scenarios/scenario_edit_session.gd.uid

@@ -0,0 +1 @@
+uid://dc74xmy3c5hy2

core/scenarios/scenario_event_mapping.gd

@@ -0,0 +1,7 @@
+@tool
+class_name ScenarioEventMapping
+extends Resource
+
+
+@export var game_event: StringName = &""
+@export var hardware_actions: Array[StringName] = []

core/scenarios/scenario_event_mapping.gd.uid

@@ -0,0 +1 @@
+uid://lixrugm1v2d2