arcade_physics_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_BALL := {
    "position": Vector2.ZERO,
    "velocity": Vector2(220, -120),
    "radius": 8.0
}
 
const DEFAULT_PADDLE := {
    "position": Vector2.ZERO,
    "size": Vector2(14, 72),
    "speed": 260.0
}
 
 
 
func create_ball(position:Vector2 = Vector2.ZERO, velocity:Vector2 = Vector2(220, -120), radius:float = 8.0) -> Dictionary:
    var ball = DEFAULT_BALL.duplicate(true)
    ball["position"] = position
    ball["velocity"] = velocity
    ball["radius"] = radius
    return ball
 
 
 
func create_paddle(position:Vector2 = Vector2.ZERO, size:Vector2 = Vector2(14, 72), speed:float = 260.0) -> Dictionary:
    var paddle = DEFAULT_PADDLE.duplicate(true)
    paddle["position"] = position
    paddle["size"] = size
    paddle["speed"] = speed
    return paddle
 
 
 
func step_ball(ball:Dictionary, delta:float, playfield:Rect2) -> Dictionary:
    var next = ball.duplicate(true)
    var radius = float(next.get("radius", 8.0))
    var previous_position:Vector2 = _vector(next.get("position", Vector2.ZERO))
    var position = previous_position + next.get("velocity", Vector2.ZERO) * delta
    var velocity = next.get("velocity", Vector2.ZERO)
    if position.y - radius < playfield.position.y:
        position.y = playfield.position.y + radius
        velocity.y = abs(velocity.y)
    elif position.y + radius > playfield.end.y:
        position.y = playfield.end.y - radius
        velocity.y = -abs(velocity.y)
    next["previous_position"] = previous_position
    next["position"] = position
    next["velocity"] = velocity
    return next
 
 
 
func step_balls(balls:Array, delta:float, playfield:Rect2, post_step:Callable = Callable()) -> Array:
    var stepped:Array = []
    for index in range(balls.size()):
        if not balls[index] is Dictionary:
            continue
        var next_ball:Dictionary = step_ball(balls[index], delta, playfield)
        if post_step.is_valid():
            next_ball = post_step.call(index, next_ball)
        stepped.append(next_ball)
    return stepped
 
 
 
func step_ball_group(primary_ball:Dictionary, extra_ball_rows:Array, delta:float, playfield:Rect2, post_step:Callable = Callable()) -> Dictionary:
    var next_primary:Dictionary = {}
    if not primary_ball.is_empty():
        next_primary = step_ball(primary_ball, delta, playfield)
        if post_step.is_valid():
            next_primary = post_step.call(-1, next_primary)
    var next_extras:Array = step_balls(extra_ball_rows, delta, playfield, post_step)
    return {
        "ball": next_primary,
        "extra_balls": next_extras,
        "count": (1 if not next_primary.is_empty() else 0) + next_extras.size()
    }
 
 
 
func collect_scoring_balls(balls:Array, playfield:Rect2) -> Dictionary:
    var scoring_sides:Array = []
    var active_balls:Array = []
    for ball_value in balls:
        if not ball_value is Dictionary:
            continue
        var scoring_side:String = get_score_side(ball_value, playfield)
        if scoring_side == "":
            active_balls.append(ball_value)
        else:
            scoring_sides.append(scoring_side)
    return {
        "scoring_sides": scoring_sides,
        "active_balls": active_balls
    }
 
 
 
func collect_ball_group_scoring(primary_ball:Dictionary, extra_ball_rows:Array, playfield:Rect2) -> Dictionary:
    var primary_scoring_side:String = ""
    if not primary_ball.is_empty():
        primary_scoring_side = get_score_side(primary_ball, playfield)
    var scoring_result:Dictionary = collect_scoring_balls(extra_ball_rows, playfield)
    var scoring_sides:Array = scoring_result.get("scoring_sides", [])
    if primary_scoring_side != "":
        scoring_sides.push_front(primary_scoring_side)
    var active_balls:Array = scoring_result.get("active_balls", [])
    var next_ball:Dictionary = primary_ball
    var next_extra_balls:Array = active_balls
    if primary_scoring_side != "":
        if not active_balls.is_empty():
            next_ball = active_balls.pop_front()
            next_extra_balls = active_balls
        else:
            next_ball = {}
    return {
        "primary_scoring_side": primary_scoring_side,
        "scoring_sides": scoring_sides,
        "next_ball": next_ball,
        "active_balls": next_extra_balls,
        "primary_promoted": primary_scoring_side != "" and not next_ball.is_empty()
    }
 
 
 
func move_paddle(paddle:Dictionary, direction:float, delta:float, playfield:Rect2) -> Dictionary:
    var next:Dictionary = paddle.duplicate(true)
    var position:Vector2 = _vector(next.get("position", Vector2.ZERO))
    var size:Vector2 = _vector(next.get("size", Vector2(14, 72)))
    position.y += clamp(direction, -1.0, 1.0) * float(next.get("speed", 260.0)) * delta
    position.y = clamp(position.y, playfield.position.y + size.y * 0.5, playfield.end.y - size.y * 0.5)
    next["position"] = position
    return next
 
 
 
func create_projectile(owner:String, position:Vector2, velocity:Vector2, radius:float = 5.0, data:Dictionary = {}) -> Dictionary:
    var projectile:Dictionary = data.duplicate(true)
    projectile["owner"] = owner
    projectile["position"] = position
    projectile["velocity"] = velocity
    projectile["radius"] = radius
    return projectile
 
 
 
func create_horizontal_projectile(source:Dictionary, owner:String, speed:float, playfield:Rect2, options:Dictionary = {}) -> Dictionary:
    if source.is_empty():
        return {}
    var direction:float = float(options.get("direction", 1.0 if owner == "player" else -1.0))
    var offset:Vector2 = _vector(options.get("offset", Vector2(direction * 16.0, 0.0)))
    var radius:float = float(options.get("radius", 5.0))
    var position:Vector2 = _vector(source.get("position", playfield.get_center())) + offset
    return create_projectile(owner, position, Vector2(direction * speed, 0.0), radius, options.get("data", {}))
 
 
 
func step_projectile(projectile:Dictionary, delta:float) -> Dictionary:
    var next:Dictionary = projectile.duplicate(true)
    next["position"] = _vector(next.get("position", Vector2.ZERO)) + _vector(next.get("velocity", Vector2.ZERO)) * delta
    return next
 
 
 
func step_projectiles(projectiles:Array, delta:float, playfield:Rect2, targets:Array = [], options:Dictionary = {}) -> Dictionary:
    var active_projectiles:Array = []
    var hits:Array = []
    var out_of_bounds:Array = []
    var margin:float = float(options.get("margin", 24.0))
    for projectile_value in projectiles:
        if not projectile_value is Dictionary:
            continue
        var stepped_projectile:Dictionary = step_projectile(projectile_value, delta)
        var hit_target:Dictionary = _projectile_hit_target(stepped_projectile, targets)
        if not hit_target.is_empty():
            hits.append({
                "projectile": stepped_projectile,
                "target_id": str(hit_target.get("id", "")),
                "target": hit_target.duplicate(true),
                "owner": str(stepped_projectile.get("owner", ""))
            })
            continue
        if projectile_out_of_bounds(stepped_projectile, playfield, margin):
            out_of_bounds.append(stepped_projectile)
            continue
        active_projectiles.append(stepped_projectile)
    return {
        "active_projectiles": active_projectiles,
        "hits": hits,
        "out_of_bounds": out_of_bounds
    }
 
 
 
func projectile_out_of_bounds(projectile:Dictionary, playfield:Rect2, margin:float = 24.0) -> bool:
    var position:Vector2 = _vector(projectile.get("position", Vector2.ZERO))
    return position.x < playfield.position.x - margin or position.x > playfield.end.x + margin or position.y < playfield.position.y - margin or position.y > playfield.end.y + margin
 
 
 
func projectile_intersects_paddle(projectile:Dictionary, paddle:Dictionary) -> bool:
    if paddle.is_empty():
        return false
    var paddle_size:Vector2 = _vector(paddle.get("size", Vector2(12, 70)))
    var paddle_rect:Rect2 = Rect2(_vector(paddle.get("position", Vector2.ZERO)) - paddle_size * 0.5, paddle_size)
    return paddle_rect.grow(float(projectile.get("radius", 5.0))).has_point(_vector(projectile.get("position", Vector2.ZERO)))
 
 
 
func create_split_ball(source_ball:Dictionary, options:Dictionary = {}) -> Dictionary:
    if source_ball.is_empty():
        return {}
    var base_velocity:Vector2 = _vector(source_ball.get("velocity", Vector2(220, 0)))
    var split_velocity:Vector2 = Vector2(base_velocity.x, -base_velocity.y)
    var min_vertical:float = float(options.get("min_vertical_speed", 130.0))
    if abs(split_velocity.y) < float(options.get("vertical_threshold", 90.0)):
        split_velocity.y = min_vertical if base_velocity.y <= 0.0 else -min_vertical
    var min_speed:float = float(options.get("min_speed", 150.0))
    var speed_ratio:float = float(options.get("speed_ratio", 0.72))
    var split_speed:float = maxf(min_speed, base_velocity.length() * speed_ratio)
    if split_velocity.length() > 0.001:
        split_velocity = split_velocity.normalized() * split_speed
    var split_ball:Dictionary = create_ball(_vector(source_ball.get("position", Vector2.ZERO)), split_velocity, float(source_ball.get("radius", 8.0)))
    if source_ball.has("last_hitter"):
        split_ball["last_hitter"] = str(source_ball.get("last_hitter", ""))
    return split_ball
 
 
 
func ball_intersects_paddle(ball:Dictionary, paddle:Dictionary, inset:Vector2 = Vector2.ZERO) -> bool:
    var position = ball.get("position", Vector2.ZERO)
    var radius = float(ball.get("radius", 8.0))
    var size = paddle.get("size", Vector2(14, 72))
    var paddle_position = paddle.get("position", Vector2.ZERO)
    var rect = Rect2(paddle_position - size * 0.5, size).grow_individual(-inset.x, -inset.y, -inset.x, -inset.y)
    var closest = Vector2(
        clamp(position.x, rect.position.x, rect.end.x),
        clamp(position.y, rect.position.y, rect.end.y)
    )
    return position.distance_to(closest) <= radius
 
 
 
func ball_swept_intersects_paddle(ball:Dictionary, paddle:Dictionary, inset:Vector2 = Vector2.ZERO) -> bool:
    if paddle.is_empty():
        return false
    var current_position:Vector2 = _vector(ball.get("position", Vector2.ZERO))
    var previous_position:Vector2 = _vector(ball.get("previous_position", current_position))
    if previous_position == current_position:
        return ball_intersects_paddle(ball, paddle, inset)
    var radius:float = float(ball.get("radius", 8.0))
    var size:Vector2 = _vector(paddle.get("size", Vector2(14, 72)))
    var paddle_position:Vector2 = _vector(paddle.get("position", Vector2.ZERO))
    var rect:Rect2 = Rect2(paddle_position - size * 0.5, size).grow_individual(-inset.x, -inset.y, -inset.x, -inset.y).grow(radius)
    return _segment_intersects_rect(previous_position, current_position, rect)
 
 
 
func bounce_from_paddle(ball:Dictionary, paddle:Dictionary, horizontal_sign:float, speedup:float = 1.04) -> Dictionary:
    var next = ball.duplicate(true)
    var velocity = next.get("velocity", Vector2.ZERO)
    var paddle_position = paddle.get("position", Vector2.ZERO)
    var paddle_size = paddle.get("size", Vector2(14, 72))
    var ball_position = next.get("position", Vector2.ZERO)
    var offset = clamp((ball_position.y - paddle_position.y) / max(1.0, paddle_size.y * 0.5), -1.0, 1.0)
    var speed = max(80.0, velocity.length() * speedup)
    var direction = Vector2(sign(horizontal_sign), offset * 0.75).normalized()
    ball_position.x = paddle_position.x + sign(horizontal_sign) * (paddle_size.x * 0.5 + float(next.get("radius", 8.0)) + 0.5)
    next["position"] = ball_position
    next["previous_position"] = ball_position
    next["velocity"] = direction * speed
    return next
 
 
 
func get_score_side(ball:Dictionary, playfield:Rect2) -> String:
    var position = ball.get("position", Vector2.ZERO)
    var radius = float(ball.get("radius", 8.0))
    if position.x + radius < playfield.position.x:
        return "right"
    if position.x - radius > playfield.end.x:
        return "left"
    return ""
 
 
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 _projectile_hit_target(projectile:Dictionary, targets:Array) -> Dictionary:
    for target_value in targets:
        if not target_value is Dictionary:
            continue
        var target:Dictionary = target_value
        if not _projectile_matches_target(projectile, target):
            continue
        var paddle:Dictionary = _dictionary(target.get("paddle", {}))
        if projectile_intersects_paddle(projectile, paddle):
            return target
    return {}
 
 
func _projectile_matches_target(projectile:Dictionary, target:Dictionary) -> bool:
    var owner:String = str(projectile.get("owner", ""))
    var owner_filters = target.get("owners", [])
    if owner_filters is Array:
        var owners:Array = owner_filters
        if not owners.is_empty() and not owners.has(owner):
            return false
    var excluded_filters = target.get("exclude_owners", [])
    if excluded_filters is Array:
        var excluded_owners:Array = excluded_filters
        if excluded_owners.has(owner):
            return false
    return true
 
 
func _dictionary(value) -> Dictionary:
    if value is Dictionary:
        return value
    return {}
 
 
func _segment_intersects_rect(start:Vector2, end:Vector2, rect:Rect2) -> bool:
    if rect.has_point(start) or rect.has_point(end):
        return true
    var delta:Vector2 = end - start
    var t_min:float = 0.0
    var t_max:float = 1.0
    if abs(delta.x) < 0.00001:
        if start.x < rect.position.x or start.x > rect.end.x:
            return false
    else:
        var inv_x:float = 1.0 / delta.x
        var tx1:float = (rect.position.x - start.x) * inv_x
        var tx2:float = (rect.end.x - start.x) * inv_x
        if tx1 > tx2:
            var temp_x:float = tx1
            tx1 = tx2
            tx2 = temp_x
        t_min = maxf(t_min, tx1)
        t_max = minf(t_max, tx2)
        if t_min > t_max:
            return false
    if abs(delta.y) < 0.00001:
        return start.y >= rect.position.y and start.y <= rect.end.y
    var inv_y:float = 1.0 / delta.y
    var ty1:float = (rect.position.y - start.y) * inv_y
    var ty2:float = (rect.end.y - start.y) * inv_y
    if ty1 > ty2:
        var temp_y:float = ty1
        ty1 = ty2
        ty2 = temp_y
    t_min = maxf(t_min, ty1)
    t_max = minf(t_max, ty2)
    return t_min <= t_max