ai_controller.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var profiles:Dictionary = {}
var data_cache_manager = DataCacheManager.new()
 
 
 
func load_profiles(file_path:String) -> void:
    profiles.clear()
    var data = data_cache_manager.load_json(file_path)
    if not data is Dictionary:
        return
    for profile in data.get("profiles", []):
        if not profile is Dictionary:
            continue
        var id:String = str(profile.get("id", ""))
        if id != "":
            profiles[id] = profile.duplicate(true)
 
 
 
func configure_profiles(next_profiles:Array) -> void:
    profiles.clear()
    for profile in next_profiles:
        if profile is Dictionary:
            var id:String = str(profile.get("id", ""))
            if id != "":
                profiles[id] = profile.duplicate(true)
 
 
 
func get_cache_stats() -> Dictionary:
    return data_cache_manager.get_cache_stats()
 
 
 
func get_profile(profile_id:String, overrides:Dictionary = {}) -> Dictionary:
    var profile:Dictionary = profiles.get(profile_id, {}).duplicate(true)
    for key in overrides.keys():
        profile[key] = overrides[key]
    return profile
 
 
 
func nearest_target(actor:Dictionary, targets:Array, options:Dictionary = {}) -> Dictionary:
    var origin:Vector2 = _position(actor)
    var best:Dictionary = {}
    var best_distance:float = INF
    for target in targets:
        if not target is Dictionary:
            continue
        if bool(options.get("alive_only", true)) and not bool(target.get("alive", true)):
            continue
        var distance:float = origin.distance_to(_position(target))
        if distance < best_distance:
            best_distance = distance
            best = target
    return best.duplicate(true)
 
 
 
func choose_paddle_action(paddle:Dictionary, balls:Array, profile:Dictionary = {}) -> Dictionary:
    var incoming_only:bool = bool(profile.get("incoming_only", true))
    var side:String = str(profile.get("side", paddle.get("side", "right")))
    var candidates:Array = []
    for ball in balls:
        if not ball is Dictionary:
            continue
        var velocity:Vector2 = _vector(ball.get("velocity", Vector2.ZERO))
        if incoming_only:
            if side == "right" and velocity.x <= 0.0:
                continue
            if side == "left" and velocity.x >= 0.0:
                continue
        candidates.append(ball)
    if candidates.is_empty():
        candidates = balls.duplicate(true)
    var target:Dictionary = nearest_target(paddle, candidates, {"alive_only": false})
    var paddle_y:float = _position(paddle).y
    var target_y:float = _position(target).y if not target.is_empty() else paddle_y
    var deadzone:float = float(profile.get("deadzone", 6.0))
    var direction:int = 0
    if target_y < paddle_y - deadzone:
        direction = -1
    elif target_y > paddle_y + deadzone:
        direction = 1
    return {
        "type": "move_axis",
        "axis": "vertical",
        "direction": direction,
        "target_id": str(target.get("id", "")),
        "confidence": float(profile.get("difficulty", 0.6))
    }
 
 
 
func choose_pong_paddle_decision(paddle:Dictionary, balls:Array, playfield:Rect2, profile:Dictionary = {}) -> Dictionary:
    var difficulty:float = clampf(float(profile.get("difficulty", 0.6)), 0.0, 1.0)
    var target:Dictionary = _nearest_arcade_ball(paddle, balls, profile)
    var paddle_position:Vector2 = _position(paddle)
    var velocity:Vector2 = _vector(target.get("velocity", Vector2.ZERO)) if not target.is_empty() else Vector2.ZERO
    var ball_position:Vector2 = _position(target) if not target.is_empty() else playfield.get_center()
    var side:String = str(profile.get("side", paddle.get("side", "right")))
    var approaching:bool = (side == "right" and velocity.x > 0.0) or (side == "left" and velocity.x < 0.0)
    var vertical_margin:float = float(profile.get("vertical_margin", 38.0))
    var target_y:float = playfield.get_center().y
    var update_delay:float = float(profile.get("idle_update_delay", 0.42))
    if approaching:
        var lead_min:float = float(profile.get("lead_time_min", 0.1))
        var lead_max:float = float(profile.get("lead_time_max", 0.24))
        var lead_time:float = lerpf(lead_min, lead_max, difficulty)
        var low_error:float = float(profile.get("tracking_error_low", -34.0))
        var high_error:float = float(profile.get("tracking_error_high", 24.0))
        if difficulty < float(profile.get("wide_error_below", 0.4)):
            low_error = float(profile.get("easy_tracking_error_low", -44.0))
            high_error = float(profile.get("easy_tracking_error_high", 10.0))
        var error_scale:float = lerpf(float(profile.get("error_scale_min_difficulty", 1.25)), float(profile.get("error_scale_max_difficulty", 0.35)), difficulty)
        var tracking_error:float = randf_range(low_error, high_error) * error_scale
        target_y = ball_position.y + velocity.y * lead_time + tracking_error
        update_delay = lerpf(float(profile.get("approach_update_delay_slow", 0.24)), float(profile.get("approach_update_delay_fast", 0.11)), difficulty)
    else:
        var idle_wander:float = float(profile.get("idle_wander", 18.0))
        target_y = playfield.get_center().y + randf_range(-idle_wander, idle_wander)
    target_y = clampf(target_y, playfield.position.y + vertical_margin, playfield.end.y - vertical_margin)
    var deadzone:float = lerpf(float(profile.get("approach_deadzone_low", 18.0)), float(profile.get("approach_deadzone_high", 6.0)), difficulty) if approaching else float(profile.get("idle_deadzone", 42.0))
    var delta_to_target:float = target_y - paddle_position.y
    var direction:float = 0.0 if abs(delta_to_target) < deadzone else sign(delta_to_target)
    return {
        "type": "move_axis",
        "axis": "vertical",
        "direction": direction,
        "target_y": target_y,
        "target_id": str(target.get("id", "")),
        "approaching": approaching,
        "update_delay": update_delay,
        "deadzone": deadzone,
        "confidence": difficulty
    }
 
 
 
func should_use_pong_powerup(actor:Dictionary, ball:Dictionary, playfield:Rect2, profile:Dictionary = {}) -> bool:
    if ball.is_empty():
        return false
    var side:String = str(profile.get("side", actor.get("side", "right")))
    var owner_required:String = str(profile.get("powerup_owner", actor.get("id", "computer")))
    if str(ball.get("owner", "")) != owner_required:
        return false
    var velocity:Vector2 = _vector(ball.get("velocity", Vector2.ZERO))
    if side == "right" and velocity.x >= 0.0:
        return false
    if side == "left" and velocity.x <= 0.0:
        return false
    var ball_position:Vector2 = _position(ball)
    var progress:float = _arcade_ball_progress(ball_position, playfield, side)
    var action_profile:Dictionary = profile.duplicate(true)
    action_profile["require_after_hit"] = bool(profile.get("require_after_hit", true))
    action_profile["min_progress"] = float(profile.get("min_progress", 0.45))
    return should_use_action(actor, {"after_hit": true, "progress": progress}, action_profile)
 
 
 
func choose_grid_action(actor:Dictionary, targets:Array, world:Dictionary = {}, profile:Dictionary = {}) -> Dictionary:
    var target:Dictionary = nearest_target(actor, targets)
    if target.is_empty():
        return {"type": "wait", "reason": "no_target"}
    var actor_cell:Vector2i = _cell(actor.get("cell", [0, 0]))
    var target_cell:Vector2i = _cell(target.get("cell", [0, 0]))
    var distance:int = abs(actor_cell.x - target_cell.x) + abs(actor_cell.y - target_cell.y)
    var attack_range:int = int(profile.get("attack_range", actor.get("attack_range", 1)))
    if distance <= attack_range:
        return {
            "type": "attack",
            "target_id": str(target.get("id", "")),
            "from": actor_cell,
            "target": target_cell,
            "damage": int(profile.get("damage", actor.get("attack", 1)))
        }
    var behavior:String = str(profile.get("behavior", actor.get("behavior", "chase")))
    if behavior == "flee":
        return _move_action(actor_cell, _step_away(actor_cell, target_cell, world), "flee", target)
    if behavior == "patrol":
        var patrol = profile.get("patrol", actor.get("patrol", []))
        if patrol is Array and not patrol.is_empty():
            return _move_action(actor_cell, _next_patrol_cell(actor_cell, patrol, world), "patrol", target)
    if behavior == "wander":
        return _move_action(actor_cell, _first_open_neighbor(actor_cell, world), "wander", target)
    return _move_action(actor_cell, _step_toward(actor_cell, target_cell, world), "chase", target)
 
 
 
func should_use_action(actor:Dictionary, context:Dictionary = {}, profile:Dictionary = {}) -> bool:
    var chance:float = float(profile.get("use_chance", actor.get("use_chance", 0.0)))
    if bool(profile.get("require_after_hit", false)) and not bool(context.get("after_hit", false)):
        return false
    if profile.has("min_progress") and float(context.get("progress", 0.0)) < float(profile.get("min_progress", 0.0)):
        return false
    return randf() <= clamp(chance, 0.0, 1.0)
 
 
func _move_action(from_cell:Vector2i, to_cell:Vector2i, reason:String, target:Dictionary) -> Dictionary:
    if to_cell == from_cell:
        return {"type": "wait", "reason": reason, "target_id": str(target.get("id", ""))}
    return {
        "type": "move",
        "from": from_cell,
        "to": to_cell,
        "reason": reason,
        "target_id": str(target.get("id", ""))
    }
 
 
func _step_toward(from_cell:Vector2i, target_cell:Vector2i, world:Dictionary) -> Vector2i:
    var options:Array = []
    if target_cell.x != from_cell.x:
        options.append(from_cell + Vector2i(sign(target_cell.x - from_cell.x), 0))
    if target_cell.y != from_cell.y:
        options.append(from_cell + Vector2i(0, sign(target_cell.y - from_cell.y)))
    return _first_open(options, from_cell, world)
 
 
func _step_away(from_cell:Vector2i, target_cell:Vector2i, world:Dictionary) -> Vector2i:
    var options:Array = []
    if target_cell.x != from_cell.x:
        options.append(from_cell - Vector2i(sign(target_cell.x - from_cell.x), 0))
    if target_cell.y != from_cell.y:
        options.append(from_cell - Vector2i(0, sign(target_cell.y - from_cell.y)))
    return _first_open(options, from_cell, world)
 
 
func _next_patrol_cell(from_cell:Vector2i, patrol:Array, world:Dictionary) -> Vector2i:
    for raw_cell in patrol:
        var next:Vector2i = _cell(raw_cell)
        if next != from_cell and _cell_open(next, world):
            return next
    return from_cell
 
 
func _first_open_neighbor(from_cell:Vector2i, world:Dictionary) -> Vector2i:
    return _first_open([
        from_cell + Vector2i.RIGHT,
        from_cell + Vector2i.LEFT,
        from_cell + Vector2i.DOWN,
        from_cell + Vector2i.UP
    ], from_cell, world)
 
 
func _first_open(options:Array, fallback:Vector2i, world:Dictionary) -> Vector2i:
    for cell in options:
        if _cell_open(cell, world):
            return cell
    return fallback
 
 
func _cell_open(cell:Vector2i, world:Dictionary) -> bool:
    var bounds = world.get("bounds", Rect2(Vector2.ZERO, Vector2(99999, 99999)))
    if bounds is Rect2:
        var tile_size:float = float(world.get("tile_size", 1.0))
        var center:Vector2 = Vector2(float(cell.x) * tile_size + tile_size * 0.5, float(cell.y) * tile_size + tile_size * 0.5)
        if not bounds.has_point(center):
            return false
    for blocked in world.get("blocked_cells", []):
        if _cell(blocked) == cell:
            return false
    return true
 
 
func _position(value) -> Vector2:
    if value is Dictionary:
        if value.has("position"):
            return _vector(value.get("position"))
        if value.has("cell"):
            var cell:Vector2i = _cell(value.get("cell"))
            return Vector2(cell.x, cell.y)
    return _vector(value)
 
 
func _nearest_arcade_ball(paddle:Dictionary, balls:Array, profile:Dictionary = {}) -> Dictionary:
    var candidates:Array = []
    var incoming_only:bool = bool(profile.get("incoming_only", true))
    var side:String = str(profile.get("side", paddle.get("side", "right")))
    for ball in balls:
        if not ball is Dictionary:
            continue
        var velocity:Vector2 = _vector(ball.get("velocity", Vector2.ZERO))
        if incoming_only:
            if side == "right" and velocity.x <= 0.0:
                continue
            if side == "left" and velocity.x >= 0.0:
                continue
        candidates.append(ball)
    if candidates.is_empty():
        candidates = balls.duplicate(true)
    var best:Dictionary = {}
    var best_score:float = INF
    var paddle_position:Vector2 = _position(paddle)
    for candidate in candidates:
        if not candidate is Dictionary:
            continue
        var position:Vector2 = _position(candidate)
        var velocity:Vector2 = _vector(candidate.get("velocity", Vector2.ZERO))
        var approaching_penalty:float = 0.0
        if side == "right" and velocity.x <= 0.0:
            approaching_penalty = 9999.0
        if side == "left" and velocity.x >= 0.0:
            approaching_penalty = 9999.0
        var score:float = abs(paddle_position.x - position.x) + approaching_penalty
        if score < best_score:
            best_score = score
            best = candidate
    return best.duplicate(true)
 
 
func _arcade_ball_progress(ball_position:Vector2, playfield:Rect2, side:String) -> float:
    if playfield.size.x <= 0.0:
        return 0.0
    var normalized:float = clampf((ball_position.x - playfield.position.x) / playfield.size.x, 0.0, 1.0)
    if side == "right":
        return 1.0 - normalized
    return normalized
 
 
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 _cell(value) -> Vector2i:
    if value is Vector2i:
        return value
    if value is Vector2:
        return Vector2i(int(value.x), int(value.y))
    if value is Array and value.size() >= 2:
        return Vector2i(int(value[0]), int(value[1]))
    if value is Dictionary and value.has("cell"):
        return _cell(value.get("cell"))
    if value is Dictionary and value.has("x") and value.has("y"):
        return Vector2i(int(value.get("x", 0)), int(value.get("y", 0)))
    return Vector2i.ZERO