Added Glitch Room Source code to Gitty

core/rooms/room_logic_engine.gd

@@ -0,0 +1,243 @@
+class_name RoomLogicEngine
+extends RefCounted
+
+
+signal event_received(
+	source_id: StringName,
+	event_id: StringName
+)
+
+signal rule_triggered(
+	rule_id: StringName,
+	source_id: StringName,
+	event_id: StringName,
+	target_id: StringName,
+	action_id: StringName
+)
+
+signal action_requested(
+	target_id: StringName,
+	action_id: StringName,
+	rule_id: StringName
+)
+
+signal trace_entry_created(
+	entry: Dictionary
+)
+
+
+var room: RoomDefinition
+
+var _pending_actions: Array[Dictionary] = []
+var _simulation_time: float = 0.0
+
+
+func configure(
+	room_definition: RoomDefinition
+) -> void:
+
+	room = room_definition
+	reset()
+
+
+func reset() -> void:
+
+	_pending_actions.clear()
+	_simulation_time = 0.0
+
+
+func get_simulation_time() -> float:
+
+	return _simulation_time
+
+
+func emit_event(
+	source_id: StringName,
+	event_id: StringName
+) -> void:
+
+	if room == null:
+		return
+
+	event_received.emit(
+		source_id,
+		event_id
+	)
+
+	_create_trace_entry(
+		&"event",
+		{
+			"source_id": source_id,
+			"event_id": event_id,
+		}
+	)
+
+	for rule in room.logic_rules:
+
+		if rule == null:
+			continue
+
+		if rule.source_id != source_id:
+			continue
+
+		if rule.event_id != event_id:
+			continue
+
+		_trigger_rule(
+			rule
+		)
+
+
+func advance(
+	delta_seconds: float
+) -> void:
+
+	if delta_seconds <= 0.0:
+		return
+
+	_simulation_time += delta_seconds
+
+	_process_pending_actions()
+
+
+func _trigger_rule(
+	rule: RoomLogicRule
+) -> void:
+
+	rule_triggered.emit(
+		rule.rule_id,
+		rule.source_id,
+		rule.event_id,
+		rule.target_id,
+		rule.action_id
+	)
+
+	_create_trace_entry(
+		&"rule",
+		{
+			"rule_id": rule.rule_id,
+			"source_id": rule.source_id,
+			"event_id": rule.event_id,
+			"target_id": rule.target_id,
+			"action_id": rule.action_id,
+			"delay_seconds": rule.delay_seconds,
+		}
+	)
+
+	if rule.delay_seconds <= 0.0:
+
+		_request_action(
+			rule.target_id,
+			rule.action_id,
+			rule.rule_id
+		)
+
+		return
+
+	_pending_actions.append(
+		{
+			"execute_at": (
+				_simulation_time
+				+ rule.delay_seconds
+			),
+
+			"target_id": (
+				rule.target_id
+			),
+
+			"action_id": (
+				rule.action_id
+			),
+
+			"rule_id": (
+				rule.rule_id
+			),
+		}
+	)
+
+
+func _process_pending_actions() -> void:
+
+	if _pending_actions.is_empty():
+		return
+
+	var ready_actions: Array[Dictionary] = []
+	var remaining_actions: Array[Dictionary] = []
+
+	for pending in _pending_actions:
+
+		var execute_at: float = (
+			pending.get(
+				"execute_at",
+				0.0
+			)
+		)
+
+		if execute_at <= _simulation_time:
+			ready_actions.append(
+				pending
+			)
+		else:
+			remaining_actions.append(
+				pending
+			)
+
+	_pending_actions = remaining_actions
+
+	for pending in ready_actions:
+
+		_request_action(
+			pending.get(
+				"target_id",
+				&""
+			),
+			pending.get(
+				"action_id",
+				&""
+			),
+			pending.get(
+				"rule_id",
+				&""
+			)
+		)
+
+
+func _request_action(
+	target_id: StringName,
+	action_id: StringName,
+	rule_id: StringName
+) -> void:
+
+	_create_trace_entry(
+		&"action",
+		{
+			"target_id": target_id,
+			"action_id": action_id,
+			"rule_id": rule_id,
+		}
+	)
+
+	action_requested.emit(
+		target_id,
+		action_id,
+		rule_id
+	)
+
+
+func _create_trace_entry(
+	entry_type: StringName,
+	data: Dictionary
+) -> void:
+
+	var entry := data.duplicate()
+
+	entry["type"] = entry_type
+	entry["time"] = _simulation_time
+
+	trace_entry_created.emit(
+		entry
+	)
+
+func has_pending_actions() -> bool:
+
+	return not _pending_actions.is_empty()