room_event_director.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const EventManager = preload("res://scripts/systems/eventManager/event_manager.gd")
 
var catalog = EventManager.new()
var rng := RandomNumberGenerator.new()
var event_chance := 0.10
var quiet_gap_min := 2
var quiet_gap_max := 5
var trade_progress_multiplier := 3.0
var next_eligible_stage := 1
var last_seen:Dictionary = {}
var errors:Array[String] = []
 
 
func _init() -> void:
    rng.randomize()
 
 
func configure(settings:Dictionary) -> void:
    event_chance = clampf(float(settings.get("event_chance", event_chance)), 0.0, 1.0)
    quiet_gap_min = maxi(1, int(settings.get("quiet_gap_min", quiet_gap_min)))
    quiet_gap_max = maxi(quiet_gap_min, int(settings.get("quiet_gap_max", quiet_gap_max)))
    trade_progress_multiplier = maxf(1.0, float(settings.get("trade_progress_multiplier", trade_progress_multiplier)))
 
 
func load_directory(path:String) -> bool:
    catalog.load_events(path)
    errors.clear()
    var seen_ids := {}
    for raw in catalog.all_events:
        if not raw is Dictionary: continue
        var event:Dictionary = raw
        var id := str(event.get("id", ""))
        if id == "":
            errors.append("Event in %s has no id" % str(event.get("pack", "?")))
        elif seen_ids.has(id):
            errors.append("Duplicate room event id: %s" % id)
        else:
            seen_ids[id] = true
        if float(event.get("weight", 0.0)) <= 0.0:
            errors.append("Room event %s needs a positive weight" % id)
        if float(event.get("duration", 0.0)) <= 0.0:
            errors.append("Room event %s needs a positive duration" % id)
        if int(event.get("minimum_objective", event.get("minimum_stage", 1))) < 1:
            errors.append("Room event %s has an invalid minimum stage" % id)
        if int(event.get("cooldown", 0)) < 0:
            errors.append("Room event %s has a negative cooldown" % id)
        if not event.get("allowed_themes", []) is Array:
            errors.append("Room event %s has invalid allowed_themes" % id)
        var visuals:Variant = event.get("visuals", [])
        if not visuals is Array:
            errors.append("Room event %s has invalid visuals" % id)
        else:
            for visual in visuals:
                if not visual is Dictionary or str(visual.get("kind", "")) not in ["ring", "circle", "rect", "glyph", "sprite"]:
                    errors.append("Room event %s has an unknown visual primitive" % id)
    if catalog.all_events.is_empty(): errors.append("No room events found in %s" % path)
    if not errors.is_empty():
        catalog.all_events.clear()
        return false
    return true
 
 
func get_definitions() -> Array:
    return catalog.all_events
 
 
func get_by_id(event_id:String) -> Dictionary:
    return catalog.get_event_by_id(event_id)
 
 
func roll(stage:int, theme:int, context:Dictionary = {}) -> Dictionary:
    if stage < next_eligible_stage or rng.randf() > event_chance: return {}
    var candidates:Array = []
    var total := 0.0
    for raw in catalog.all_events:
        var event:Dictionary = raw
        var id := str(event.get("id", ""))
        if stage < int(event.get("minimum_objective", event.get("minimum_stage", 1))): continue
        if stage - int(last_seen.get(id, -100000)) < int(event.get("cooldown", 0)): continue
        var allowed:Array = event.get("allowed_themes", [])
        if not allowed.is_empty() and theme not in allowed: continue
        var required_item := str(event.get("requires_item", ""))
        if required_item != "" and int(context.get("inventory", {}).get(required_item, 0)) <= 0: continue
        var inventory:Dictionary = context.get("inventory", {})
        var missing_requirement := false
        for required in event.get("requires_all", []):
            if int(inventory.get(str(required), 0)) <= 0: missing_requirement = true
        if missing_requirement: continue
        var blocked_by_item := false
        for excluded in event.get("excludes_items", []):
            if int(inventory.get(str(excluded), 0)) > 0: blocked_by_item = true
        if blocked_by_item: continue
        var once_key := str(event.get("once_key", ""))
        if once_key != "" and bool(context.get("trade_flags", {}).get(once_key, false)): continue
        var effective_weight := float(event.get("weight", 1.0))
        if str(event.get("trade_kind", "")) != "" and (required_item != "" or not event.get("requires_all", []).is_empty()):
            effective_weight *= float(event.get("progress_multiplier", trade_progress_multiplier))
        total += effective_weight
        candidates.append({"event":event, "limit":total})
    if candidates.is_empty(): return {}
    var roll_value := rng.randf_range(0.0, total)
    for candidate in candidates:
        if roll_value <= float(candidate.limit):
            var picked:Dictionary = candidate.event
            last_seen[str(picked.get("id", ""))] = stage
            next_eligible_stage = stage + rng.randi_range(quiet_gap_min, quiet_gap_max)
            return picked
    return {}
 
 
func reset() -> void:
    last_seen.clear()
    next_eligible_stage = 1
 
 
func get_state() -> Dictionary:
    return {"last_seen":last_seen.duplicate(true), "next_eligible_stage":next_eligible_stage}
 
 
func set_state(state:Dictionary) -> void:
    last_seen = state.get("last_seen", {}).duplicate(true)
    next_eligible_stage = maxi(1, int(state.get("next_eligible_stage", 1)))