在某个系统内部，您可以生成Bundle。

fn my_system(mut cmds: Commands) {
    let map_length = 1920;
    let map_depth = 1920;
    let sector_resolution = 640;
    let actor_size = 16.0;
    cmds.spawn(FlowFieldTilesBundle::new(map_length, map_depth, sector_resolution, actor_size));
}

请注意，这将初始化代表世界的所有 CostFields，其单元格值为 1。这意味着所有地方都可以通行，很可能会需要用真实值初始化字段。

在3D中，您可以考虑向每个FieldCell中心发射射线，并使用射线的 y 位置来确定是否可以通行，然后翻转该特定 FieldCell 的值（可以使用 EventUpdateCostfieldsCell 来排队成本更改）。

对于2D或更复杂的3D场景，您可能希望启用 ron、csv 或 heightmap 功能，这允许从 .ron 文件、一组 .csv 或灰度png/jpeg（其中像素颜色通道被转换为成本）创建 FlowFieldTilesBundle，初始 CostFields，示例展示了这一点的详细信息。

路径请求

当与算法交互时，这基于在可移动角色需要路径时发出的事件。

struct EventPathRequest {
    /// The starting sector of the request
    source_sector: SectorID,
    /// The starting field cell of the starting sector
    source_field_cell: FieldCell,
    /// The sector to try and find a path to
    target_sector: SectorID,
    /// The field cell in the target sector to find a path to
    target_goal: FieldCell,
}

每个参数都可以通过查询Bundle的 MapDimension 组件，并使用角色的起始和目标位置变换来确定。

使用一些示例组件来跟踪和标记角色

/// Enables easy querying of Actor entities
#[derive(Component)]
struct Actor;
/// Consumed by an Actor steering pipeline to produce movement
#[derive(Default, Component)]
struct Pathing {
    target_position: Option<Vec2>,
    metadata: Option<RouteMetadata>,
    portal_route: Option<Vec<(SectorID, FieldCell)>>,
    has_los: bool,
}

然后我们可以做一些类似的事情，处理鼠标点击，分配一个角色一个 target_position（在3D中使用以xyz结尾的方法）

fn user_input(
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    camera_q: Query<(&Camera, &GlobalTransform)>,
    dimensions_q: Query<&MapDimensions>,
    mut actor_q: Query<&mut Pathing, With<Actor>>,
) {
    if mouse_button_input.just_released(MouseButton::Right) {
        // get 2d world positionn of cursor
        let (camera, camera_transform) = camera_q.single();
        let window = windows.single();
        if let Some(world_position) = window
            .cursor_position()
            .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
            .map(|ray| ray.origin.truncate())
        {
            let map_dimensions = dimensions_q.get_single().unwrap();
            if map_dimensions
                .get_sector_and_field_cell_from_xy(world_position)
                .is_some()
            {
                let mut pathing = actor_q.get_single_mut().unwrap();
                // update the actor pathing
                pathing.target_position = Some(world_position);
                pathing.metadata = None;
                pathing.portal_route = None;
                pathing.has_los = false;
            } else {
                error!("Cursor out of bounds");
            }
        }
    }
}

角色可以查询 RouteCache 以获取路径 - 或者如果不存在，可以发出请求以生成路径。

fn get_or_request_route(
    route_q: Query<(&RouteCache, &MapDimensions)>,
    mut actor_q: Query<(&Transform, &mut Pathing), With<Actor>>,
    mut event: EventWriter<EventPathRequest>,
) {
    let (route_cahe, map_dimensions) = route_q.get_single().unwrap();
    for (tform, mut pathing) in &mut actor_q {
        if let Some(target) = pathing.target_position {
            // actor has no route, look one up or request one
            if pathing.portal_route.is_none() {
                if let Some((source_sector, source_field)) =
                    map_dimensions.get_sector_and_field_cell_from_xy(tform.translation.truncate())
                {
                    if let Some((target_sector, goal_id)) =
                        map_dimensions.get_sector_and_field_cell_from_xy(target)
                    {
                        // if a route is calculated get it
                        if let Some((metadata, route)) = route_cahe.get_route_with_metadata(
                            source_sector,
                            source_field,
                            target_sector,
                            goal_id,
                        ) {
                            pathing.metadata = Some(*metadata);
                            pathing.portal_route = Some(route.clone());
                        } else {
                            // request a route
                            event.send(EventPathRequest::new(
                                source_sector,
                                source_field,
                                target_sector,
                                goal_id,
                            ));
                        }
                    }
                }
            }
        }
    }
}

一旦构建了 FlowFields，它们可以查询 FlowFieldCache 并执行/排队某种类型的移动。

注意，这个示例非常基础，因为它只处理单个角色，在应用程序中，您将设计自己的处理系统

const SPEED: f32 = 64.0;
fn actor_steering(
    mut actor_q: Query<(&mut LinearVelocity, &mut Transform, &mut Pathing), With<Actor>>,
    flow_cache_q: Query<(&FlowFieldCache, &MapDimensions)>,
    time_step: Res<Time>,
) {
    let (flow_cache, map_dimensions) = flow_cache_q.get_single().unwrap();
    for (mut velocity, tform, mut pathing) in actor_q.iter_mut() {
        // lookup the overarching route
        if let Some(route) = pathing.portal_route.as_mut() {
            // find the current actors postion in grid space
            if let Some((curr_actor_sector, curr_actor_field_cell)) =
                map_dimensions.get_sector_and_field_cell_from_xy(tform.translation.truncate())
            {
                // trim the actor stored route as it makes progress
                // this ensures it doesn't use a previous goal from
                // a sector it has already been through when it needs
                // to pass through it again as part of a different part of the route
                if let Some(f) = route.first() {
                    if curr_actor_sector != f.0 {
                        route.remove(0);
                    }
                }
                // lookup the relevant sector-goal of this sector
                'routes: for (sector, goal) in route.iter() {
                    if *sector == curr_actor_sector {
                        // get the flow field
                        if let Some(field) = flow_cache.get_field(*sector, *goal) {
                            // based on actor field cell find the directional vector it should move in
                            let cell_value = field.get_field_cell_value(curr_actor_field_cell);
                            if has_line_of_sight(cell_value) {
                                pathing.has_los = true;
                                let dir =
                                    pathing.target_position.unwrap() - tform.translation.truncate();
                                velocity.0 = dir.normalize() * SPEED * time_step.delta_seconds();
                                break 'routes;
                            }
                            let dir = get_2d_direction_unit_vector_from_bits(cell_value);
                            if dir.x == 0.0 && dir.y == 0.0 {
                                warn!("Stuck");
                                pathing.portal_route = None;
                            }
                            velocity.0 = dir * SPEED * time_step.delta_seconds();
                        }
                        break 'routes;
                    }
                }
            }
        }
    }
}

注意：生成的FlowFields和Routes在15分钟后从其缓存中过期，如果依赖的某个角色过期，您的引导管道可能需要发送新的 EventPathRequest。

注意：当修改CostField时，门户和门户图会更新，涉及修改扇区CostField的任何路径或FlowFields都将被删除 - 它们将被重新生成，但CharacterController需要能够处理从缓存中消失并返回的路径（如果可以返回，CostField的更新可能会使路径无效，因为路径不存在）。

可能使路径请求出错的事情

如果您将此与物理模拟结合使用，请确保您的CharacterController非常稳健，考虑以下可能发生的情况

• 移动中的角色碰撞到将其弹入其路径之外的扇区的物体。角色如何知道发生了这种情况并请求新路径？
• 一个演员已逃逸/隧道逸出你的世界（其翻译超出MapDimensions边界），应该销毁还是重新定位使其在边界内？

功能

• serde - 为某些数据类型启用序列化
• ron - 启用从文件中读取 CostField。注意：在.ron中的固定大小数组被写入为元组
• csv - 通过从csv文件目录中读取，创建所有 CostFields。注意：csv文件名需要遵循column_row.csv的部门ID约定，下划线很重要，目录的路径应该是完全限定的，并且文件本身不应包含任何标题
• 2d - 在2d世界中处理Flowfields时启用接口方法，此外还允许使用Bevy 2d网格列表初始化Flowfields
• 3d - 在3d世界中处理FlowFields时启用接口方法
• heightmap - 允许从灰度png/jpeg初始化 CostField，其中图像的每个像素代表一个 FieldCell。Alpha通道是可选的（如果包含在图像中，将被忽略）。颜色通道为 (0, 0, 0, 255)（黑色）表示不可通行的 255 成本，而 (255, 255, 255, 255)（白色）表示 1 成本，介于两者之间的通道值将代表更昂贵的成本

性能

基准测试分为两类

• 数据初始化
  • init_cost_fields - 测量初始化100x100部门 CostFields 所需的时间
  • init_portals - 测量在100x100部门中构建 Portals 所需的时间
  • init_portal_graph - 测量构建100x100部门的 PortalGraph 所需的时间
  • init_bundle - 测量准备好 FlowFieldTilesBundle 所需的总时间
• 算法使用 - 测量生成一组FlowFields
  • calc_route - 测量从一个100x100部门布局的一个角落生成到对角角落的路线所需的时间
  • calc_flow_open - 测量创建一组完整的 FlowFields 所需的时间，这些字段描述了在均匀 CostFields（成本 = 1）上从一角到另一角的运动
  • calc_flow_sparse - 测量创建一组完整的 FlowFields 所需的时间，这些字段描述了在包含不可通行地块块的多个部门中运动
  • calc_flow_maze - 测量创建一个完整的描述在100x100区域世界中从一个角落移动到另一个角落所需的时间 FlowFields。世界由垂直走廊组成，这意味着演员必须上下移动，最终蜿蜒到达目标

目前最慢的部分是生成 PortalGraph（在我的机器上7秒），因此这应该是幕后发生的一些初始化（例如加载界面或其他类似内容）。

根据路径复杂性的不同，我看到的 FlowField 生成时间在5-90毫秒之间。

授权协议

MIT和Apache双授权。