event_manager.gd

Go to the documentation of this file.

 
 
 
const RARITY_WEIGHTS = {"common":20,"uncommon":10,"rare":4,"epic":1}
const DEFAULT_EVENT_PACK_DIR = "res://data/games/reflecting_pool/events"
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var all_events = []
var events_by_pack = {}
var current_event = {}
var data_cache_manager = DataCacheManager.new()
 
 
func load_events(event_pack_dir:String = DEFAULT_EVENT_PACK_DIR) -> void:
    load_event_packs(event_pack_dir)
 
func load_event_packs(event_pack_dir:String = DEFAULT_EVENT_PACK_DIR) -> void:
    all_events.clear()
    events_by_pack.clear()
    current_event = {}
    var dir = DirAccess.open(event_pack_dir)
    if dir:
        dir.list_dir_begin()
        var f = dir.get_next()
        while f != "":
            if f.ends_with(".json"):
                var pack_id = f.substr(0, f.length() - 5)
                load_event_pack(pack_id, event_pack_dir + "/" + f)
            f = dir.get_next()
 
 
func load_event_pack(pack_id:String, file_path:String) -> void:
    load_event_pack_data(pack_id, data_cache_manager.load_root_array(file_path))
 
 
 
func load_event_pack_data(pack_id:String, data:Array) -> void:
    if not events_by_pack.has(pack_id):
        events_by_pack[pack_id] = []
    for raw_event in data:
        if not raw_event is Dictionary:
            continue
        var event = raw_event.duplicate(true)
        if not event.has("pack"):
            event["pack"] = pack_id
        events_by_pack[pack_id].append(event)
        all_events.append(event)
 
 
func get_events(filters:Dictionary = {}) -> Array:
    var events = []
    for event in all_events:
        if _event_matches_filters(event, filters):
            events.append(event)
    return events
 
func get_pack_ids() -> Array:
    return events_by_pack.keys()
 
func get_events_in_pack(pack_id:String) -> Array:
    return events_by_pack.get(pack_id, [])
 
func _event_matches_filters(event:Dictionary, filters:Dictionary) -> bool:
    if filters.has("pack") and event.get("pack", "") != filters["pack"]:
        return false
    if filters.has("packs") and not filters["packs"].has(event.get("pack", "")):
        return false
    if filters.has("rarity") and event.get("rarity", "common") != filters["rarity"]:
        return false
    if filters.has("rarities") and not filters["rarities"].has(event.get("rarity", "common")):
        return false
    if filters.has("repeatable") and bool(event.get("repeatable", true)) != bool(filters["repeatable"]):
        return false
    return true
 
 
func get_weighted_event(filters:Dictionary = {}) -> Dictionary:
    var event_pool = get_events(filters)
    if event_pool.is_empty():
        return {}
    var total = 0
    for e in event_pool:
        total += RARITY_WEIGHTS.get(e.get("rarity", "common"), 20)
    if total <= 0:
        return event_pool[0]
    var roll = randi_range(1, total)
    var running = 0
    for e in event_pool:
        running += RARITY_WEIGHTS.get(e.get("rarity", "common"), 20)
        if roll <= running:
            return e
    return event_pool[0]
    
 
func next_event(filters:Dictionary = {}) -> Dictionary:
    current_event = get_weighted_event(filters)
    return current_event
 
func get_event_by_id(event_id:String) -> Dictionary:
    for event in all_events:
        if str(event.get("id", "")) == event_id:
            return event
    return {}
 
 
func set_current_event_by_id(event_id:String) -> bool:
    var event = get_event_by_id(event_id)
    if event.is_empty():
        return false
    current_event = event
    return true
 
 
func draw_events(count:int, filters:Dictionary = {}, allow_duplicates:bool = false) -> Array:
    var drawn_events = []
    var event_pool = get_events(filters)
    for i in range(count):
        if event_pool.is_empty():
            break
        var event = _get_weighted_event_from_pool(event_pool)
        drawn_events.append(event)
        if not allow_duplicates:
            event_pool.erase(event)
    return drawn_events
 
func _get_weighted_event_from_pool(event_pool:Array) -> Dictionary:
    var total = 0
    for e in event_pool:
        total += RARITY_WEIGHTS.get(e.get("rarity", "common"), 20)
    if total <= 0:
        return event_pool[0]
    var roll = randi_range(1, total)
    var running = 0
    for e in event_pool:
        running += RARITY_WEIGHTS.get(e.get("rarity", "common"), 20)
        if roll <= running:
            return e
    return event_pool[0]
 
func get_current_event() -> Dictionary:
    return current_event
 
func get_current_event_id() -> String:
    return str(current_event.get("id", ""))
 
func get_current_title() -> String:
    return current_event.get("title", "Event")
 
func get_current_description() -> String:
    return current_event.get("description", "")
 
func get_current_choices() -> Array:
    return current_event.get("choices", [])
 
func get_choice_text(choice:Dictionary) -> String:
    return choice.get("text", "Choice")
 
func get_choice_effects(choice:Dictionary) -> Array:
    return choice.get("effects", [])
 
func get_choice_outcome(choice:Dictionary) -> String:
    return choice.get("outcome", "")
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()