Godot Genre Romance

# affection_manager.gd
# Handles multi-axis relationship tracking, gift systems, and milestone triggers.
# Optimized for Godot 4.x with static typing and Signal-driven architecture.

class_name AffectionManager
extends Node

## Emitted when a relationship reaches a specific threshold.
signal milestone_reached(character_id: String, milestone_index: int, data: Dictionary)

## Emitted whenever any stats change. Useful for UI updates.
signal stats_changed(character_id: String, new_stats: Dictionary)

enum RelationStat { ATTRACTION, TRUST, COMFORT }

const MIN_STAT = -100
const MAX_STAT = 100

# Dictionary structure: { "character_id": { "attraction": 0, "trust": 0, "comfort": 0, "gift_history": {} } }
var _relationship_data: Dictionary = {}

## Adds to a specific stat for a character.
## Usage: AffectionManager.add_stat("alice", AffectionManager.RelationStat.TRUST, 5)
func add_stat(character_id: String, stat: RelationStat, amount: int) -> void:
	_ensure_character(character_id)
	
	var stat_name: String = _get_stat_name(stat)
	var current_val: int = _relationship_data[character_id][stat_name]
	var new_val: int = clamp(current_val + amount, MIN_STAT, MAX_STAT)
	
	_relationship_data[character_id][stat_name] = new_val
	stats_changed.emit(character_id, _relationship_data[character_id])
	_check_milestones(character_id, stat_name, new_val)

## Handles gift giving with diminishing returns logic.
func give_gift(character_id: String, item_data: Dictionary) -> int:
	_ensure_character(character_id)
	
	var base_value: int = item_data.get("value", 5)
	var gift_id: String = item_data.get("id", "generic")
	
	# Diminishing returns calculation
	var history: Dictionary = _relationship_data[character_id].get("gift_history", {})
	var times_given: int = history.get(gift_id, 0)
	
	# Formula: reduce effectiveness by 20% each time, floor at 1 point
	var multiplier: float = max(0.2, 1.0 - (times_given * 0.2))
	var final_amount: int = int(ceil(base_value * multiplier))
	
	# Apply to Attraction by default for gifts
	add_stat(character_id, RelationStat.ATTRACTION, final_amount)
	
	# Update history
	history[gift_id] = times_given + 1
	_relationship_data[character_id]["gift_history"] = history
	
	return final_amount

func get_stats(character_id: String) -> Dictionary:
	_ensure_character(character_id)
	return _relationship_data[character_id].duplicate()

func _ensure_character(character_id: String) -> void:
	if not _relationship_data.has(character_id):
		_relationship_data[character_id] = {
			"attraction": 0,
			"trust": 0,
			"comfort": 0,
			"milestones": [], # indices of milestones already fired
			"gift_history": {}
		}

func _get_stat_name(stat: RelationStat) -> String:
	match stat:
		RelationStat.ATTRACTION: return "attraction"
		RelationStat.TRUST: return "trust"
		RelationStat.COMFORT: return "comfort"
	return ""

func _check_milestones(character_id: String, _stat_name: String, value: int) -> void:
	# Example threshold-based milestones
	var thresholds = [20, 50, 80]
	var record = _relationship_data[character_id]
	
	for i in range(thresholds.size()):
		if value >= thresholds[i] and not i in record["milestones"]:
			record["milestones"].append(i)
			milestone_reached.emit(character_id, i, {"stat": _stat_name, "value": value})

# date_event_system.gd
# Manages date logic, location preferences, and outcome calculations.
# Designed to be used with a Resource-based system for DateLocations (not included).

class_name DateEventSystem
extends Node

## Emitted when a date concludes.
signal date_finished(character_id: String, outcome: String, score: int)

## Emitted when a specific interaction occurs during a date.
signal date_interaction(character_id: String, dialogue_key: String)

enum Outcome { DISASTER, MILD, SUCCESS, PERFECT }

# Tracker to prevent "Same Date Order" trap
# { "character_id": ["park", "cafe", "cinema"] }
var _date_history: Dictionary = {}

## Evaluates a date at a given location.
## location_data structure: { "id": "park", "trust_weight": 0.5, "attraction_weight": 1.5, "thresholds": [0, 10, 30, 50] }
func evaluate_date(character_id: String, location_data: Dictionary, choice_modifiers: int = 0) -> Outcome:
	var stats: Dictionary = AffectionManager.get_stats(character_id)
	
	# Weighted success calculation
	var score: float = 0.0
	score += stats["attraction"] * location_data.get("attraction_weight", 1.0)
	score += stats["trust"] * location_data.get("trust_weight", 1.0)
	score += stats["comfort"] * location_data.get("comfort_weight", 1.0)
	score += choice_modifiers
	
	# Apply variety penalty if same location repeated recently
	var history = _date_history.get(character_id, [])
	if history.size() > 0 and history[-1] == location_data["id"]:
		score *= 0.7 # 30% penalty for repetitiveness
		date_interaction.emit(character_id, "repetitive_date_complaint")
	
	# Add to history
	_add_to_history(character_id, location_data["id"])
	
	# Determine outcome
	var result_score = int(score)
	var thresholds = location_data.get("thresholds", [-10, 10, 30, 60])
	var outcome: Outcome = Outcome.DISASTER
	
	if result_score >= thresholds[3]: outcome = Outcome.PERFECT
	elif result_score >= thresholds[2]: outcome = Outcome.SUCCESS
	elif result_score >= thresholds[1]: outcome = Outcome.MILD
	
	_apply_outcome_rewards(character_id, outcome)
	date_finished.emit(character_id, _get_outcome_string(outcome), result_score)
	
	return outcome

func _add_to_history(character_id: String, location_id: String) -> void:
	if not _date_history.has(character_id):
		_date_history[character_id] = []
	_date_history[character_id].append(location_id)
	if _date_history[character_id].size() > 5:
		_date_history[character_id].remove_at(0)

func _get_outcome_string(outcome: Outcome) -> String:
	match outcome:
		Outcome.DISASTER: return "DISASTER"
		Outcome.MILD: return "MILD"
		Outcome.SUCCESS: return "SUCCESS"
		Outcome.PERFECT: return "PERFECT"
	return "UNKNOWN"

func _apply_outcome_rewards(char_id: String, outcome: Outcome) -> void:
	match outcome:
		Outcome.PERFECT:
			AffectionManager.add_stat(char_id, AffectionManager.RelationStat.ATTRACTION, 10)
			AffectionManager.add_stat(char_id, AffectionManager.RelationStat.TRUST, 5)
		Outcome.SUCCESS:
			AffectionManager.add_stat(char_id, AffectionManager.RelationStat.ATTRACTION, 5)
		Outcome.DISASTER:
			AffectionManager.add_stat(char_id, AffectionManager.RelationStat.TRUST, -5)
			AffectionManager.add_stat(char_id, AffectionManager.RelationStat.ATTRACTION, -2)

extends Node
class_name DialogueExpressionParser

## Expert Dialogue Logic (Godot 4.6).
## Evaluates complex conditions at runtime using the Expression class.

func can_show_choice(condition: String, player_stats: Dictionary) -> bool:
	if condition.is_empty(): return true
	
	var expression = Expression.new()
	# Example: condition = "affection >= 20"
	var error = expression.parse(condition, player_stats.keys())
	
	if error != OK:
		push_error("Dialogue condition parse error: " + expression.get_error_text())
		return false
	
	var result = expression.execute(player_stats.values())
	return result if result is bool else false

## [SKILL NOTICE]: Use 'Expression' to evaluate dialogue conditions. 
## It is much faster and safer than writing a custom logic parser in GDScript.

extends Node

## Expert Affection Tracker (Godot 4.6).
## Global Singleton for decoupled relationship management.

signal affection_updated(npc_id: String, new_val: int, change: int)

var _npc_data: Dictionary = {} # npc_id: current_affection

func modify_affection(npc_id: String, amount: int) -> void:
	var current = _npc_data.get(npc_id, 0)
	_npc_data[npc_id] = current + amount
	
	# Expert Pattern: Decouple from UI using Signals
	affection_updated.emit(npc_id, _npc_data[npc_id], amount)

func get_affection(npc_id: String) -> int:
	return _npc_data.get(npc_id, 0)

## [SKILL NOTICE]: Use 'Signals' inside an 'Autoload' to notify the UI 
## of affection changes without the dialogue system needing to know it exists.

extends CanvasLayer
class_name RomanceMoodManager

## Expert Mood Orchestrator (Godot 4.6).
## Manages atmospheric filters and character transitions.

@export var mood_overlay: ColorRect
@export var portrait_node: TextureRect

func transition_to_mood(color: Color, time: float = 1.0) -> void:
	var tween = create_tween().set_trans(Tween.TRANS_SINE)
	tween.tween_property(mood_overlay, "color", color, time)

func crossfade_portrait(new_tex: Texture2D, time: float = 0.5) -> void:
	var tween = create_tween().set_parallel(true)
	# Fade out old, Fade in new
	tween.tween_property(portrait_node, "modulate:a", 0.0, time / 2)
	tween.chain().tween_callback(func(): portrait_node.texture = new_tex)
	tween.tween_property(portrait_node, "modulate:a", 1.0, time / 2)

## [SKILL NOTICE]: Use a 'ColorRect' as a screen-space overlay to instantly 
## shift the emotional tone (sad, romantic, intense) of 2D narrative scenes.

# romance_patterns.gd
extends Node

# 1. Type-Safe Affection Dictionary
# EXPERT NOTE: Use StringNames for fast lookups in narrative state tracking.
var affection_stats: Dictionary[StringName, int] = {
    &"CharacterA": 0,
    &"CharacterB": 0
}

# 2. Custom RichTextEffect for Emotive Text
# EXPERT NOTE: Create dynamic text animations (like shaking) via BBCode effects.
@tool
class_name ShakeEffect extends RichTextEffect
var bbcode := "shake"
func _process_custom_fx(char_fx: CharFXTransform) -> bool:
    char_fx.transform = char_fx.transform.translated(Vector2(randf_range(-1, 1), 0))
    return true

# 3. Context-Aware Localization
# EXPERT NOTE: Resolves ambiguities (e.g., "Close" the door vs "Close" in distance).
func print_dialogue(label: Label, key: String, context: StringName) -> void:
    label.text = tr(key, context)

# 4. Connecting Meta Clicks for Hyperlinked Choices
# EXPERT NOTE: Captures clicks on [url] tags inside the RichTextLabel for interactive logs.
func setup_meta_links(rtl: RichTextLabel) -> void:
    rtl.meta_clicked.connect(func(meta): OS.shell_open(str(meta)))

# 5. Typewriter Effect via Tweens
# EXPERT NOTE: Cleaner than using _process timers; allows easy speed control.
func play_typewriter(label: RichTextLabel, duration: float) -> void:
    label.visible_ratio = 0.0
    var tween := create_tween()
    tween.tween_property(label, "visible_ratio", 1.0, duration)

# 6. Serializing Preferences via ConfigFile
# EXPERT NOTE: Ideal for global settings like "Skip Read Text" or "Auto Play".
func save_romance_settings(path: String, skip_read: bool) -> void:
    var config := ConfigFile.new()
    config.set_value("Dialogue", "skip_read", skip_read)
    config.save(path)

# 7. Unbinding Signals for Generic Advance
# EXPERT NOTE: Drops the default boolean argument emitted by buttons for clean callbacks.
func connect_advance_btn(btn: Button, callback: Callable) -> void:
    btn.pressed.connect(callback.unbind(1))

# 8. Handling Pluralization Safely
# EXPERT NOTE: Properly translates "1 rose" vs "2 roses" based on locale rules.
func get_gift_text(amount: int) -> String:
    return atr_n("You received %s rose.", "You received %s roses.", amount) % amount

# 9. Dynamic Choice Button Injection
# EXPERT NOTE: Instances buttons for branching choices based on narrative state.
func populate_choices(container: Control, choices: Array[StringName], callback: Callable) -> void:
    for choice in choices:
        var btn := Button.new()
        btn.text = tr(choice)
        btn.pressed.connect(callback.bind(choice))
        container.add_child(btn)

# 10. Hiding UI for CG Views (Cinematic)
# EXPERT NOTE: Use alpha modulation to smoothly transition between UI and CG art.
func toggle_ui_visibility(canvas: CanvasLayer, is_visible: bool) -> void:
    var tween := create_tween()
    tween.tween_property(canvas, "modulate:a", 1.0 if is_visible else 0.0, 0.5)

# route_manager.gd
# Manages character-specific narrative routes, persistence, and endings.
# Integrated with the AffectionManager for milestone-based route unlocking.

class_name RouteManager
extends Node

## Emitted when the player officially enters a character's route.
signal route_locked_in(character_id: String)

## Emitted when a new CG (Computer Graphic) or Gallery item is unlocked.
signal cg_unlocked(cg_id: String)

enum EndingType { BAD, NORMAL, GOOD, TRUE }

# State tracking
var current_route: String = ""
var is_route_active: bool = false
var unlocked_cgs: Array[String] = []

# Persistent data for gallery/completionist features
const SAVE_PATH = "user://romance_gallery.save"

func _ready() -> void:
	load_gallery()
	# Connect to affection milestones to potentially trigger route entries
	# AffectionManager.milestone_reached.connect(_on_affection_milestone)

## Attempts to lock in a character's route. 
## Returns true if successful, false if already on another route.
func lock_in_route(character_id: String) -> bool:
	if is_route_active:
		if current_route == character_id:
			return true
		else:
			push_warning("Attempted to enter %s route while already on %s route." % [character_id, current_route])
			return false
	
	current_route = character_id
	is_route_active = true
	unlock_cg(character_id + "_prologue")
	route_locked_in.emit(character_id)
	return true

## Unlocks a CG and saves to persistent storage.
func unlock_cg(cg_id: String) -> void:
	if not cg_id in unlocked_cgs:
		unlocked_cgs.append(cg_id)
		cg_unlocked.emit(cg_id)
		save_gallery()

## Pure logic for determining ending based on stats.
func determine_ending(character_id: String) -> EndingType:
	var stats: Dictionary = AffectionManager.get_stats(character_id)
	
	if stats["trust"] < 0:
		return EndingType.BAD
	
	if stats["attraction"] >= 80 and stats["trust"] >= 50:
		if stats["comfort"] >= 70:
			return EndingType.TRUE
		return EndingType.GOOD
	
	return EndingType.NORMAL

# --- Persistence ---

func save_gallery() -> void:
	var file = FileAccess.open(SAVE_PATH, FileAccess.WRITE)
	if file:
		var data = {
			"unlocked_cgs": unlocked_cgs,
			"global_progress": {} # Can store multi-playthrough flags here
		}
		file.store_var(data)

func load_gallery() -> void:
	if FileAccess.file_exists(SAVE_PATH):
		var file = FileAccess.open(SAVE_PATH, FileAccess.READ)
		if file:
			var data = file.get_var()
			unlocked_cgs = data.get("unlocked_cgs", [])