top_down_controller_2d.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
const DEFAULT_CONFIG := {
    "speed": 160.0,
    "radius": 10.0,
    "tile_size": 40.0
}
 
 
 
func create_state(position := Vector2.ZERO, config := {}) -> Dictionary:
    var merged = _merged_config(config)
    return {
        "position": position,
        "velocity": Vector2.ZERO,
        "radius": float(merged.get("radius", DEFAULT_CONFIG["radius"])),
        "grid": world_to_grid(position, merged)
    }
 
 
 
func step(state:Dictionary, input:Dictionary, delta:float, bounds:Rect2, obstacles:Array, config := {}) -> Dictionary:
    var merged = _merged_config(config)
    var next_state = state.duplicate(true)
    var move = input.get("move", Vector2.ZERO)
    if not move is Vector2:
        move = Vector2.ZERO
    if move.length() > 1.0:
        move = move.normalized()
    var speed = float(merged.get("speed", DEFAULT_CONFIG["speed"]))
    var radius = float(next_state.get("radius", merged.get("radius", DEFAULT_CONFIG["radius"])))
    var velocity = move * speed
    var position = next_state.get("position", Vector2.ZERO)
    position = _move_axis(position, Vector2(velocity.x * delta, 0), radius, bounds, obstacles)
    position = _move_axis(position, Vector2(0, velocity.y * delta), radius, bounds, obstacles)
    next_state["position"] = position
    next_state["velocity"] = velocity
    next_state["radius"] = radius
    next_state["grid"] = world_to_grid(position, merged)
    return next_state
 
 
 
func step_grid(state:Dictionary, direction:Vector2i, bounds:Rect2, blocked_cells:Array, config := {}) -> Dictionary:
    var merged = _merged_config(config)
    var next_state = state.duplicate(true)
    if direction == Vector2i.ZERO:
        return next_state
    var current_cell = next_state.get("grid", world_to_grid(next_state.get("position", Vector2.ZERO), merged))
    if not current_cell is Vector2i:
        current_cell = Vector2i(int(current_cell.x), int(current_cell.y))
    var target_cell = current_cell + direction
    if _grid_cell_blocked(target_cell, bounds, blocked_cells, merged):
        next_state["velocity"] = Vector2.ZERO
        return next_state
    next_state["grid"] = target_cell
    next_state["position"] = grid_to_world(target_cell, merged)
    next_state["velocity"] = Vector2(direction) * float(merged.get("tile_size", DEFAULT_CONFIG["tile_size"]))
    return next_state
 
 
func world_to_grid(position:Vector2, config := {}) -> Vector2i:
    var merged = _merged_config(config)
    var tile_size = max(1.0, float(merged.get("tile_size", DEFAULT_CONFIG["tile_size"])))
    return Vector2i(int(floor(position.x / tile_size)), int(floor(position.y / tile_size)))
 
 
func grid_to_world(cell:Vector2i, config := {}) -> Vector2:
    var merged = _merged_config(config)
    var tile_size = max(1.0, float(merged.get("tile_size", DEFAULT_CONFIG["tile_size"])))
    return Vector2(float(cell.x) * tile_size + tile_size * 0.5, float(cell.y) * tile_size + tile_size * 0.5)
 
 
func rect_to_cells(rect:Rect2, config := {}) -> Array:
    var merged = _merged_config(config)
    var tile_size = max(1.0, float(merged.get("tile_size", DEFAULT_CONFIG["tile_size"])))
    var min_cell = Vector2i(int(floor(rect.position.x / tile_size)), int(floor(rect.position.y / tile_size)))
    var max_cell = Vector2i(int(floor((rect.position.x + max(0.0, rect.size.x - 0.01)) / tile_size)), int(floor((rect.position.y + max(0.0, rect.size.y - 0.01)) / tile_size)))
    var cells := []
    for y in range(min_cell.y, max_cell.y + 1):
        for x in range(min_cell.x, max_cell.x + 1):
            cells.append(Vector2i(x, y))
    return cells
 
 
func trace_grid_line(origin:Vector2i, direction:Vector2i, max_range:int, bounds:Rect2, blocked_cells:Array, config := {}) -> Array:
    var cells := []
    var current = origin
    for _index in range(max(0, max_range)):
        current += direction
        if _grid_cell_blocked(current, bounds, blocked_cells, config):
            break
        cells.append(current)
    return cells
 
 
func _move_axis(position:Vector2, offset:Vector2, radius:float, bounds:Rect2, obstacles:Array) -> Vector2:
    if offset == Vector2.ZERO:
        return _clamp_to_bounds(position, radius, bounds)
    var current = _clamp_to_bounds(position, radius, bounds)
    var steps = max(1, int(ceil(offset.length() / max(1.0, radius * 0.5))))
    var step_offset = offset / float(steps)
    for _index in range(steps):
        var candidate = _clamp_to_bounds(current + step_offset, radius, bounds)
        if _collides(candidate, radius, obstacles):
            return current
        current = candidate
    return current
 
 
func _collides(position:Vector2, radius:float, obstacles:Array) -> bool:
    for obstacle in obstacles:
        var rect := Rect2()
        if obstacle is Rect2:
            rect = obstacle
        elif obstacle is Dictionary and obstacle.has("rect"):
            rect = obstacle.get("rect")
        else:
            continue
        if rect.grow(radius).has_point(position):
            return true
    return false
 
 
func _grid_cell_blocked(cell:Vector2i, bounds:Rect2, blocked_cells:Array, config:Dictionary) -> bool:
    var world_position = grid_to_world(cell, config)
    if not bounds.has_point(world_position):
        return true
    for blocked in blocked_cells:
        if blocked is Vector2i and blocked == cell:
            return true
        if blocked is Vector2 and Vector2i(int(blocked.x), int(blocked.y)) == cell:
            return true
        if blocked is Dictionary and blocked.has("cell"):
            var blocked_cell = blocked.get("cell")
            if blocked_cell is Vector2i and blocked_cell == cell:
                return true
    return false
 
 
func _clamp_to_bounds(position:Vector2, radius:float, bounds:Rect2) -> Vector2:
    if bounds.size == Vector2.ZERO:
        return position
    return Vector2(
        clamp(position.x, bounds.position.x + radius, bounds.position.x + bounds.size.x - radius),
        clamp(position.y, bounds.position.y + radius, bounds.position.y + bounds.size.y - radius)
    )
 
 
func _merged_config(config:Dictionary) -> Dictionary:
    var merged = DEFAULT_CONFIG.duplicate(true)
    for key in config.keys():
        merged[key] = config[key]
    return merged