arcade_powerup_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var definitions:Dictionary = {}
var spawn_config := {
    "max_active": 2,
    "lifetime": 10.0,
    "min_delay": 1.0,
    "max_delay": 2.0,
    "followup_min_delay": 0.7,
    "followup_max_delay": 1.5,
    "pace": 1.0,
    "collect_radius": 12.0,
    "x_margin_ratio": 0.25,
    "y_margin": 28.0
}
var active_powerups:Array = []
var spawn_timer:float = 0.0
var data_cache_manager = DataCacheManager.new()
var powerup_ids_cache:Array = []
var labels_by_id:Dictionary = {}
var colors_by_id:Dictionary = {}
var effects_by_id:Dictionary = {}
var cache_hits:int = 0
var cache_misses:int = 0
 
 
 
func load_definitions(file_path:String, options:Dictionary = {}) -> Array:
    var parsed = data_cache_manager.load_json(file_path)
    if not parsed is Dictionary:
        configure([], options)
        return []
    configure(parsed.get("powerups", []), options)
    return get_powerup_ids()
 
 
 
func get_cache_stats() -> Dictionary:
    var stats:Dictionary = data_cache_manager.get_cache_stats()
    stats["definitions"] = definitions.size()
    stats["cached_ids"] = powerup_ids_cache.size()
    stats["cached_labels"] = labels_by_id.size()
    stats["cached_colors"] = colors_by_id.size()
    stats["cached_effect_lists"] = effects_by_id.size()
    stats["runtime_cache_hits"] = cache_hits
    stats["runtime_cache_misses"] = cache_misses
    return stats
 
 
 
func configure(next_definitions, options:Dictionary = {}) -> void:
    definitions.clear()
    if next_definitions is Array:
        for row in next_definitions:
            if row is Dictionary:
                var id:String = str(row.get("id", ""))
                if id != "":
                    definitions[id] = row.duplicate(true)
            else:
                definitions[str(row)] = {"id": str(row)}
    elif next_definitions is Dictionary:
        for id in next_definitions.keys():
            var value = next_definitions[id]
            definitions[str(id)] = value.duplicate(true) if value is Dictionary else {"id": str(id)}
    for key in options.keys():
        spawn_config[key] = options[key]
    _rebuild_definition_indexes()
 
 
func get_powerup_ids() -> Array:
    cache_hits += 1
    return powerup_ids_cache.duplicate()
 
 
func get_definition(powerup_id:String) -> Dictionary:
    if definitions.has(powerup_id):
        cache_hits += 1
        return Dictionary(definitions.get(powerup_id, {})).duplicate(true)
    cache_misses += 1
    return definitions.get(powerup_id, {"id": powerup_id, "label": powerup_id.capitalize()}).duplicate(true)
 
 
func get_label(powerup_id:String) -> String:
    if labels_by_id.has(powerup_id):
        cache_hits += 1
        return str(labels_by_id.get(powerup_id, powerup_id.capitalize()))
    cache_misses += 1
    return powerup_id.capitalize()
 
 
func get_color(powerup_id:String, fallback:Color = Color.WHITE) -> Color:
    if colors_by_id.has(powerup_id):
        cache_hits += 1
        return colors_by_id.get(powerup_id, fallback)
    cache_misses += 1
    return fallback
 
 
 
func apply_effects(powerup_id:String, context:Dictionary = {}, handlers:Dictionary = {}) -> Array:
    var operations:Array = []
    var effects:Array = effects_by_id.get(powerup_id, []) if effects_by_id.get(powerup_id, []) is Array else []
    if effects.is_empty():
        cache_misses += 1
    else:
        cache_hits += 1
    for effect in effects:
        if not effect is Dictionary:
            continue
        var operation := normalize_effect(powerup_id, effect, context)
        if operation.is_empty():
            continue
        operations.append(operation)
        _dispatch_effect(operation, handlers)
    return operations
 
 
 
func normalize_effect(powerup_id:String, effect:Dictionary, context:Dictionary = {}) -> Dictionary:
    var operation:Dictionary = effect.duplicate(true)
    var effect_type:String = str(operation.get("type", ""))
    if effect_type == "":
        return {}
    operation["type"] = effect_type
    operation["powerup_id"] = powerup_id
    operation["label"] = str(operation.get("label", get_label(powerup_id)))
    if context.has("recipient"):
        operation["recipient"] = str(context.get("recipient", ""))
    if operation.has("duration"):
        operation["duration"] = float(operation.get("duration", 0.0))
    match effect_type:
        "clear_timer":
            operation["type"] = "set_timer"
            operation["duration"] = 0.0
        "effect_label":
            operation["duration"] = float(operation.get("duration", 5.0))
        "slow_opponent":
            var slow_recipient:String = str(context.get("recipient", "player"))
            operation["timer"] = "opponent_slow" if slow_recipient == "player" else "player_slow"
            operation["type"] = "set_timer"
            operation["duration"] = float(operation.get("duration", 10.0))
        "curve_boost":
            var curve_recipient:String = str(context.get("recipient", "player"))
            operation["timer"] = "player_curve_boost" if curve_recipient == "player" else "opponent_curve_boost"
            operation["type"] = "set_timer"
            operation["duration"] = float(operation.get("duration", 10.0))
    return operation
 
 
 
func update(delta:float, playfield:Rect2, collectors:Array, options:Dictionary = {}) -> Dictionary:
    for key in options.keys():
        spawn_config[key] = options[key]
    var events:Dictionary = {"spawned": [], "collected": [], "expired": []}
    spawn_timer -= delta
    if active_powerups.size() < int(spawn_config.get("max_active", 2)) and spawn_timer <= 0.0:
        var spawned:Dictionary = spawn(playfield)
        if not spawned.is_empty():
            events["spawned"].append(spawned)
        spawn_timer = next_spawn_delay(active_powerups.size() < int(spawn_config.get("max_active", 2)))
    var remaining:Array = []
    for powerup in active_powerups:
        var next_powerup:Dictionary = powerup.duplicate(true)
        next_powerup["age"] = float(next_powerup.get("age", 0.0)) + delta
        if float(next_powerup.get("age", 0.0)) >= float(spawn_config.get("lifetime", 10.0)):
            events["expired"].append(next_powerup)
            spawn_timer = min(spawn_timer, next_spawn_delay(true) * 0.7)
            continue
        var collector:Dictionary = find_collector(next_powerup, collectors)
        if not collector.is_empty():
            next_powerup["collector"] = str(collector.get("owner", ""))
            next_powerup["collector_id"] = str(collector.get("id", ""))
            events["collected"].append(next_powerup)
            spawn_timer = min(spawn_timer, next_spawn_delay(true))
        else:
            remaining.append(next_powerup)
    active_powerups = remaining
    return events
 
 
 
func spawn(playfield:Rect2, powerup_id:String = "") -> Dictionary:
    var ids:Array = definitions.keys()
    if ids.is_empty():
        return {}
    var id:String = powerup_id if powerup_id != "" else str(ids[randi() % ids.size()])
    var x_margin:float = playfield.size.x * float(spawn_config.get("x_margin_ratio", 0.25))
    var y_margin:float = float(spawn_config.get("y_margin", 28.0))
    var row:Dictionary = {
        "id": "%s_%d" % [id, Time.get_ticks_msec()],
        "type": id,
        "position": Vector2(
            randf_range(playfield.position.x + x_margin, playfield.end.x - x_margin),
            randf_range(playfield.position.y + y_margin, playfield.end.y - y_margin)
        ),
        "age": 0.0
    }
    active_powerups.append(row)
    return row.duplicate(true)
 
 
 
func find_collector(powerup:Dictionary, collectors:Array) -> Dictionary:
    var powerup_position:Vector2 = _vector(powerup.get("position", Vector2.ZERO))
    for collector in collectors:
        if not collector is Dictionary:
            continue
        var radius:float = float(collector.get("radius", 8.0)) + float(spawn_config.get("collect_radius", 12.0))
        if _vector(collector.get("position", Vector2.ZERO)).distance_to(powerup_position) <= radius:
            return collector.duplicate(true)
    return {}
 
 
func next_spawn_delay(wants_followup:bool) -> float:
    var min_delay:float = float(spawn_config.get("followup_min_delay" if wants_followup else "min_delay", 0.7))
    var max_delay:float = float(spawn_config.get("followup_max_delay" if wants_followup else "max_delay", 1.5))
    var pace:float = maxf(0.1, float(spawn_config.get("pace", 1.0)))
    return maxf(0.25, randf_range(min_delay, max_delay) / pace)
 
 
func clear() -> void:
    active_powerups.clear()
    spawn_timer = 0.0
 
 
func get_active() -> Array:
    return active_powerups.duplicate(true)
 
 
func set_active(rows:Array) -> void:
    active_powerups = rows.duplicate(true)
 
 
func get_state() -> Dictionary:
    return {
        "active_powerups": active_powerups.duplicate(true),
        "spawn_timer": spawn_timer,
        "spawn_config": spawn_config.duplicate(true)
    }
 
 
func apply_state(state:Dictionary) -> void:
    active_powerups = state.get("active_powerups", []).duplicate(true)
    spawn_timer = float(state.get("spawn_timer", spawn_timer))
    var saved_config = state.get("spawn_config", {})
    if saved_config is Dictionary:
        for key in saved_config.keys():
            spawn_config[key] = saved_config[key]
 
 
func _dispatch_effect(operation:Dictionary, handlers:Dictionary) -> void:
    var effect_type:String = str(operation.get("type", ""))
    var handler_key:String = effect_type
    if not handlers.has(handler_key):
        handler_key = "custom_effect"
    var handler = handlers.get(handler_key, Callable())
    if handler is Callable and handler.is_valid():
        if handler_key == "custom_effect":
            handler.call(operation)
        else:
            handler.call(operation)
 
 
func _vector(value) -> Vector2:
    if value is Vector2:
        return value
    if value is Vector2i:
        return Vector2(value.x, value.y)
    if value is Array and value.size() >= 2:
        return Vector2(float(value[0]), float(value[1]))
    if value is Dictionary and value.has("x") and value.has("y"):
        return Vector2(float(value.get("x", 0.0)), float(value.get("y", 0.0)))
    return Vector2.ZERO
 
 
func _rebuild_definition_indexes() -> void:
    powerup_ids_cache = definitions.keys()
    powerup_ids_cache.sort()
    labels_by_id.clear()
    colors_by_id.clear()
    effects_by_id.clear()
    cache_hits = 0
    cache_misses = 0
    for id in powerup_ids_cache:
        var powerup_id:String = str(id)
        var definition:Dictionary = definitions.get(powerup_id, {}) if definitions.get(powerup_id, {}) is Dictionary else {}
        labels_by_id[powerup_id] = str(definition.get("label", powerup_id.capitalize()))
        if definition.has("color"):
            colors_by_id[powerup_id] = Color(str(definition.get("color", "#ffffff")))
        var effects:Array = []
        for effect in definition.get("effects", []):
            if effect is Dictionary:
                effects.append(Dictionary(effect).duplicate(true))
        effects_by_id[powerup_id] = effects