文档未完成，最近一次更新于2025/10/18。进度-5.4

海风团的各位，大家好啊。这里是天罡（贴吧id：天罡陌路）

最近对游戏引擎Bevy比较感兴趣。正好海风团设有技术小组，本着共同分享、共同进步的原则，这里就斗胆献丑将我的学习过程发布给各位，还望各位大佬能多多指正、不吝赐教。当然，如果有人能因我的教程得到帮助，那便再荣幸不过了。

好了，接下来进入正题。

在这篇入门笔记中，我将一步步分享如何通过RustRover新建Bevy项目并制作一个简陋的2D俯视角射击游戏。

由于Bevy引擎暂时还并不是一个成熟的引擎，因此这里建议各位至少对Rust编程语言具备一定了解之后再去尝试。如果你还没有Rust基础，我建议你可以看看https://course.rs/about-book.html

在这篇笔记中，我将假定各位已经安装了Rust并了解其语法结构。

本笔记中，我的工具版本如下：

Rust：1.90.0 (1159e78c4 2025-09-14)

IDE：RustRover 2025.2.3（非商业用途免费）

Bevy：0.17.2

1. 什么是Bevy？

Bevy 是一款使用 Rust 语言构建的现代化、模块化、数据驱动的开源游戏引擎。它的设计目标是让游戏开发既强大又简单，无论是初学者还是资深开发者都能快速上手并享受高效的开发过程。

核心架构	采用实体组件系统（ECS），将数据与逻辑分离，使代码更模块化、高性能且易于维护。
语言与性能	基于 Rust 语言，无需垃圾回收（GC），从而避免帧率波动，实现低延迟和高性能。
功能范围	提供完整的 2D 和 3D 功能集，支持现代图形技术如PBR（基于物理的渲染）。
开发体验	支持热重载，无需重启游戏即可看到代码和资源的更改效果，大幅提升开发效率。
设计哲学	高度模块化，你可以只选择需要的功能模块，甚至可以替换引擎的默认组件。
平台支持	支持跨平台开发，包括 Windows, macOS, Linux 以及 Web（通过 WebAssembly）。

请注意：

Bevy目前属于新兴游戏引擎，工具链几乎没有，UI系统不完善甚至编辑器都没一个，因此它目前还很不适合无编码背景的初学者上手投入实战。（当然你想试试也可以，不过得提前学一下Rust）

不过Bevy目前还在快速更新迭代，0.18将推出BSN，编辑器肯定也不远了（估计也就明年上半年的事），我相信它是绝对未来可期的，它将在五年内成为由Rust打造的最强游戏引擎，蟹门！！

2. 从RustRover新建一个Bevy项目

首先，我们新建一个Rust项目，并将其命名为“bevy_shoot”。

新建完成后，我们进入终端，为项目引入Bevy（请保证网络畅通，如果下载速度过慢，可以考虑为自己的Rust设置镜像源，教程如：https://juejin.cn/post/7528393617641013263）。

接着，为项目引入Bevy（第一次引入可能比较慢，因为需要从cargo源下载到你的电脑上）

在本地终端中输入"cargo add bevy"。

回车执行。等待导入，完成后我们去检查项目的Cargo.toml文件，发现内容已经发生变化。

至此我们已经成功为项目导入了Bevy。

这里多说一句，这里我们可以看到啊我们安装的Bevy版本为0.17.2，这是因为我们的终端指令是“cargo add bevy”，cargo会自动从库中寻找最新的bevy版本导入你的项目。如果需要指定版本，比如你想导入0.12.1，那么你在终端输入的指令就应当是“cargo add bevy@0.12.1”。

另外，你还可以视情况为cargo.toml添加些东西，使开发体验更顺畅。

具体参照官网https://bevy.org/learn/quick-start/getting-started/setup/ ，这里就不做过多赘述了。

3. 快速了解Bevy的ECS架构

首先，我们先将src文件夹下的main.rs文件进行修改，将原本的自动生成代码替换为以下内容。

use bevy::prelude::*;

fn main() {
    App::new().run();
}

这段代码的内容很简单，就是在主函数中生成一个Bevy App实例。这个实例不会做任何事，所以当你运行程序后也不会有任何效果。但是，我们可以编写一些具备实际功能的模块（Plugin），并将其挂在到Bevy App对象上，使其能够运行。

这里我们就仿照官方的示例，从控制台输出Hello World开始。

让我们先定义一个输出Hello World的函数。

fn hello_world() {
    println!("Hello, World!");
}

然后我们对main函数稍作修改，将它挂载到App对象中。

fn main() {
    App::new()  						//Bavy App实例化
        .add_systems(Update,hello_world)//将hello_world函数挂载至App上
        .run(); 						//运行Bevy App
}

这次，当我们点击运行后，控制台就将输出“Hello World!”了。

【PS】第一次编译时间比较长是正常的，但要是每次编译时间都很长，可以参照官网https://bevy.org/learn/quick-start/getting-started/setup/ 的优化方案

好的，现在，让我们回到代码，看看这一切怎么发生的。

输出hello world的函数大伙应该都了解，问题是，add_system()是怎么回事？让我们先看看IDE给我们的提示：

Adds one or more systems to the given schedule in this app's Schedules.

将一个或多个System加入至App调度集的指定调度(schedule)中。

你应该看出来了。是的，“add_systems(Update,hello_world)”的作用，便是将一个叫hello_world的System添加进一个名为Update的调度集中。

这里涉及到了Bevy一个十分重要的概念，即Schedules（调度集）。

考虑到这里只是个入门笔记，所以Schedules就不细讲了。你只需要将它看作Bevy的日程表就行了，它的作用就好像一个用于提示使用者在什么时候需要做什么事情的日程表一样，让Bevy App在对应时间点执行其内挂载的System。

我们重点讲一下ECS。相信你们在看到前面的时候一定会有一个疑问：hello_world()不是一个函数吗？为什么在add_system()中它又被称为系统（System）了？

这涉及到了ECS的基本概念：

ECS（Entity-Component-System，实体-组件-系统）是一种在游戏开发和实时应用中广泛使用的架构模式，它通过将数据、标识和行为分离来优化性能和组织结构。其中：

Entity（实体）：实体只是一个概念上的定义，指的是存在你游戏世界中的一个独特物体，是一系列组件的集合。

Component（组件）：纯粹的数据集合，表示实体的属性，它没有行为，只用来存储状态。

System（系统）：对拥有一个或多个相同组件的实体集合进行操作的工具，它只有行为，没有状态，即不应该存放任何数据。

从这里你应该发现了：Entity表示游戏内实体本身，Component表示实体的数据，而System表示实体的行为。

举个例子，我们为我们的游戏设计一个怪物，那么这个怪物本身就是一个Entity（实体），它的血量、名字、攻击力、立绘等属性项目就是它的Component（组件），而它攻击、放技能、逃跑等行为就是System（系统）。

插个题外话，我不知道你有没有了解过Unity的GameObject-Component架构。两者思想上是有相似之处的，GameObject与Entity定位是类似的（但GameObject包含了更多标识性的属性），但Unity的Component相当于ECS架构中的Component + System，耦合度更高。

让我们把视线拉回到Bevy。ECS算是Bevy作为游戏引擎的一个核心理念，当我们理解ECS后，我们再回过头看看Bevy对ECS的实现，就很清晰明了了：

Entity（实体）：在Bevy中是多个组件的集合体，通常通过Commands::spawn()创建，具备一个由程序生成的唯一整数标识（ID）。
Component（组件）：在Bevy中是一类用Rust结构体（struct）或枚举（enum）定义的数据，例如位置、血量。
System（系统）：在Bevy中是普通的Rust函数，其参数定义了它需要查询和操作的数据（如组件、资源）。

因此，hello_world()作为一个Rust函数，它被Bevy App视作一个System是很正常的事。

接下来，我们不妨尝试改动一下这个hello_world，完成我们对ECS的实践：让我们不仅只对整个世界说“hello”，也要对着具体的人“hello”。

那么，让我们定义一个人出来。考虑到ECS模式，我们得先将我们需要的组件列出来。

由于只做个问候，因此有个名字就行了。

//标记组件
#[derive(Component)]
struct Person;

//名称组件，名称是人这个Entity的一个属性，没什么可说的。这里用了一个元组结构体
#[derive(Component)]
struct Name(String);

#[derive()]是一个Rust的属性宏，作用是自动为结构体（struct）或枚举（enum）实现Trait，从而免去手动实现的麻烦，这里的#[derive(Component)]作用就是自动为其标注的结构体或枚举实现Bevy ECS 里一个名为“Component”的Trait，使其成为Bevy ECS体系内的组件(Component)。

接着，我们需要将这两个组件拼合成一个Entity，我们通过一个函数实现它。

fn add_people(mut commands: Commands) {
    commands.spawn((Person,Name("U No.1".to_string())));
    commands.spawn((Person,Name("ML".to_string())));
}

我在这个函数中调用了两次Commands::spawn()。当这个函数被执行时，程序将生成两个实体（Entity），每个实体都将包含一个Person组件和一个Name组件，分别指代一个叫“U No.1”的人和一个叫“ML”的人。

接下来，我们需要将这个函数挂载到Bevy App上，同样通过add_systems()。

fn main() {
    App::new()
        .add_systems(Startup,add_people) //将add_people挂载到Bevy App上
        .add_systems(Update,hello_world)
        .run();
}

你可能已经发现了，两个函数被挂载到了不同的调度集里，一个是Update，一个是Startup。这个我相信有其他引擎使用经验的人应该已经反应过来是什么含义了，没反应过来也没事，我后面会讲。

接着，我们继续写给不同人问好的函数，然后挂载到Bevy App上。

fn main() {
    App::new()
        .add_systems(Startup,add_people)
        .add_systems(Update,(hello_world,hello_people)) //将hello_people加入Update调度集
        .run();
}

//给不同人问好的函数
fn hello_people(query: Query<&Name, With<Person>>) {
    for name in query.iter() {
        println!("hello {}", name.0);
    }
}

点击运行，结果为

相信你到此时的疑惑很多，我们一样样来：

为什么要定义Person这么个空的组件？

为了给Entity分类与标记。

我们已经了解到，ECS思想中，实体（Entity）实际上只是一堆组件（Component）的集合，是一个概念，这意味着它们之间本身是没有类型分别的。举个例子：游戏中玩家角色是一个实体，但他手里的武器也是一个实体，那么，当我们需要处理游戏环境中的实体时，我们该如何区分角色和武器呢？这个Person就是个例子，我们可以为实体添加一个专门用于区分不同类别实体的标记性组件，它实际上相当于是实体类型的名字。

而这个Person的作用已经在hello_people()中体现了，我们看看这个函数的签名：

fn hello_people(query: Query<&Name, With<Person>>)

发现了没？这个With<Person>就是筛选用的，Query<&Name,With<Person>>的含义就是：从已有的Entity中筛选出带有Person组件的实体，并获取该实体的Name组件的引用。

当然，实际开发中我们还有一种方式可以将Entity所需的组件通过这类标记性的组件一次性打包出来，这个我们后面再说。

【为什么hello_world()和hello_people()的执行顺序与代码中它们被加入Update调度集的顺序不一致？】

因为调度集内的System默认是并行执行的，调度器会自动分析System之间的数据依赖关系，无冲突的 System会同时运行。所以hello_world()与hello_people()哪个先执行完成是没准信的。

如果你一定要控制这些system的执行顺序呢？你一定要先hello_world()再hello_person()呢？

这里有个方法，就是chain()：

fn main() {
    App::new()
        .add_systems(Startup,add_people)
        .add_systems(Update,(hello_world,hello_people).chain())//添加chain()
        .run();
}

chain()可以保证调度器严格按照编码队列里的顺序执行System。

【hello_people()以及之前的add_people()的参数怎么传递进来的？】

答案是Bevy的依赖注入机制。

Bevy 的依赖注入机制是其 ECS 架构的核心驱动力之一，它以一种声明式且类型安全的方式，将系统所需的依赖自动注入，从而让代码更清晰、更模块化，并极大地提升了可测试性。

简单来说，Bevy App会为挂载的System的签名的特定类型参数传递实参，你不需要手动创建这些参数并传递给系统，Bevy 的调度器在系统运行前，会自动分析函数的签名，并从 ECS World（一个包含所有实体、组件、资源的全局容器）中查找并注入所需的依赖。

Bevy主要的可注入参数大致是这些：

参数类型	核心作用	典型使用场景
`Query<Q, F>`	查询并操作符合条件的一系列实体及其组件。ECS 的核心。	遍历所有带 `Transform`和 `Velocity`的实体来更新位置。
`Res<T>`	只读访问全局唯一的资源 `T`。	读取 `Time`资源获取帧间隔；读取 `AssetServer`加载资源。
`ResMut<T>`	可变访问全局唯一的资源 `T`。	修改 `GameState`；写入 `NextState`来请求状态转换。
`Commands`	延迟执行对世界的修改（生成/删除实体，添加/移除组件等）。	在系统执行中生成一个新实体；为某个实体添加一个效果组件。
`MessageReader<T>`	读取本帧已发送的 `T`类型消息。	接收 `MouseClick`消息，并判断点击了哪里。
`MessageWriter<T>`	发送`T`类型的消息，供后续系统或本帧稍后处理。	玩家按下攻击键时，发送一个 `PlayerAttack`消息。
`Local<T>`	系统内部的私有状态，其值在系统多次运行间保持。	一个计数器；一个 FSM 的当前状态。
`&World`	只读访问整个 ECS 世界。最底层、最灵活的访问方式。	进行复杂的跨原型(Archetype)查询；动态获取组件类型。
`ParamSet<(...)>`	临时捆绑多个通常不兼容的参数（如多个 `QueryMut`）。	需要同时可变地查询两组不同的实体，但它们可能有交集。
`NonSend<T>`	只读访问 `!Send`资源（非线程安全的资源）。	操作外部图形 API 的句柄（如 OpenGL context）。
`NonSendMut<T>`	可变访问 `!Send`资源。	配置非线程安全的第三方库。
`On<T>`	响应观察者事件。`T`通常是 `Add`, `Insert`, `Remove`等与一个组件组合。	当任何实体被添加 `Health`组件时，初始化其血量。

4. 生命周期、插件、资源与游戏窗口

现在既然我们已经成功HelloWorld了，对Bevy最核心的ECS思想也有了解了，那么我们就可以讨论一些更接近游戏流程与展示的内容了。

4.1. 生命周期

不知道你们还记不记得前面被我一笔带过的，前文提到的关于调度集的事。我当时将add_people()与hello_people()分别挂载到了Startup与Update两个不同的调度集，为什么？

你应该还记得我前面对于调度集的比喻，日程表，对吧？

让我将日程表的“日程”替换为Bevy App的生命周期，“待办事项”替换为各种挂载的System。然后举几个代表性的调度集例子：

生命周期	调度集	核心职责与执行时机
核心应用生命周期	`Startup`	应用启动时运行一次，用于初始化资源、生成实体等。
	`Update`	应用运行时每一帧都执行，是游戏逻辑（如输入、物理、AI）的核心。
	`FixedUpdate`	以固定的物理时间间隔运行，独立于渲染帧率，常用于物理模拟。
状态生命周期	`OnEnter(state)`	当游戏进入某个特定状态时运行一次，用于状态初始化。
	`OnExit(state)`	当游戏离开某个特定状态时运行一次，用于状态清理。
渲染管线	`PreUpdate`	在 `Update`之前运行，通常用于处理输入等需要在主逻辑前完成的任务。
	`PostUpdate`	在 `Update`之后运行，用于同步世界状态，为渲染做准备。
	`ExtractSchedule`	从 ECS 世界提取渲染所需的数据，准备传递给渲染器。
	`Render`	包含多个子阶段（如 `Prepare`, `Queue`），负责向 GPU 提交渲染命令。

对比一下，答案便已经明了了：将add_people()挂载到Startup调度集是因为创建两个实体这个行为只需要执行一次就行了，将hello_people()挂载到Update调度集是为了每一帧都问候一次。

看到这里，你肯定会想：不对啊，程序运行起来后Update上挂载的System只执行了一次就退出了啊！

别急。

这是因为我们还没有将bevy管理游戏主循环的内置插件挂载上去。现在让我们引入Bevy内置插件集DefaultPlugins：

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)	//将Bevy默认插件集挂载至Bevy App
        .add_systems(Startup,add_people)
        .add_systems(Update,(hello_world,hello_people).chain())
        .run();
}

然后，让我们对people的两个函数来点“小巧思”（个人恶趣味，你跳过这步也行）：

fn add_people(mut commands: Commands) {
    commands.spawn((Person,Name("木÷".to_string())));
    commands.spawn((Person,Name("冲÷".to_string())));
}

fn hello_people(query: Query<&Name, With<Person>>) {
    for name in query.iter() {
        println!("{}，NMSL！！", name.0);
    }
}

接着，点击运行。**Bingo**！

好了，现在你会发现程序运行起来后出现了一个游戏窗口，而只要这个窗口不关闭，那么挂载在Update调度集上的System将不断每帧循环执行，高强度在控制台输出“Hello World”的同时问候木冲二÷。

你现在应该明白了，是的，这个多出来的游戏窗口才是我们后续做的游戏的游玩窗口，前面的控制台什么的都只是开发阶段的玩意。

不过，在深入窗口之前，我们还是得先讲一下插件（Plugin）。

4.2. 插件（Plugin）

你应该发现了，Bevy的很多基础功能都是以插件的形式打包在DefaultPlugins里的，哪怕最基本的游戏窗口和游戏主循环都是如此，这正是Bevy自身另一个设计哲学的体现：模块化。而在Bevy中，模块化哲学的主要体现就是插件。

Bevy 的插件（Plugin）系统是其架构的核心，它完美体现了“模块化”的设计哲学。简单来说，Bevy 引擎本身的几乎所有功能，甚至你的整个游戏，都是以插件的形式组织和运行的。这让你能像搭积木一样，自由选择和组合所需功能。而DefaultPlugins就是官方提供的“基础插件全家桶”，包含创建基础应用（如窗口、渲染、输入）所需的核心功能。是大多数项目的起点。

此外，我们自己在使用Bevy进行游戏开发时也将遵循这套哲学，将自己游戏的功能和逻辑打包成一个个模块化的插件，从而极大降低游戏后续维护与二次开发的难度，并提高代码的可复用性。

不过，一直到目前为止，我们的代码中是没有自定义的模块的，前面的所有行为都是以System的形式直接挂载到了Bevy App的调度集里。所以让我们着手尝试把前面问候木冲的代码改成plugin吧！

我们先定义一个叫HelloPlugin的插件。

//定义一个名为HelloPlugin的结构体
pub struct HelloPlugin;
//只有实现Bevy的trait Plugin后，我们自定义的HelloPlugin才会被视为插件
impl Plugin for HelloPlugin {
    fn build(&self, app: &mut App) {
        //TODO
    }
}

Plugin的核心方法build控制着插件的初始化行为，其参数app实际上就是我们在main函数中实例化的Bevy App。因此，我们可以将main中add_systems移入HelloPlugin的build，以保持main函数的整洁。

于是main.rs大致变成了这样：

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(HelloPlugin)
        .run();
}

pub struct HelloPlugin;

impl Plugin for HelloPlugin {
    fn build(&self, app: &mut App) {
        //将main中与本插件相关的add_systems行为全部移入这里
        app
            .add_systems(Startup,add_people)
            .add_systems(Update,(hello_world,hello_people).chain());
    }
}

#[derive(Component)]
struct Person;

#[derive(Component)]
struct Name(String);

fn add_people(mut commands: Commands) {
    commands.spawn((Person,Name("木÷".to_string())));
    commands.spawn((Person,Name("冲÷".to_string())));
}

fn hello_world() {
    println!("hello world");
}

fn hello_people(query: Query<&Name, With<Person>>) {
    for name in query.iter() {
        println!("{}，NMSL！！", name.0);
    }
}

点击执行，你会发现运行结果和之前并没有什么区别。区别只是我们将说hello的相关内容全部打包到HelloPlugin里了而已。

到这里，我们已经做出了自己的第一个插件（即HelloPlugin）。

更进一步的，我们可以将HelloPlugin从main中脱离。在src文件夹下新建一个hello_plugin.rs插件，然后将main.rs中有关HelloPlugin的内容全部移到hello_plugin.rs中，然后我们得到了这个：

hello_plugin.rs:

use bevy::prelude::*;

pub struct HelloPlugin;

impl Plugin for HelloPlugin {
	fn build(&self, app: &mut App) {
		app
			.add_systems(Startup,add_people)
			.add_systems(Update,(hello_world,hello_people).chain());
	}
}

#[derive(Component)]
struct Person;

#[derive(Component)]
struct Name(String);

fn add_people(mut commands: Commands) {
	commands.spawn((Person,Name("木÷".to_string())));
	commands.spawn((Person,Name("冲÷".to_string())));
}

fn hello_world() {
	println!("hello world");
}

fn hello_people(query: Query<&Name, With<Person>>) {
	for name in query.iter() {
		println!("{}，NMSL！！", name.0);
	}
}

main.rs

use bevy::prelude::*;

//这两句是为了引入hello_plugin.rs文件中的内容
mod hello_plugin;
use crate::hello_plugin::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(HelloPlugin)
        .run();
}

最后运行结果依旧与之前保持一致，只是代码被分割到了多个文件中。

4.3. 资源

在Bevy中，除了最基础的ECS以外，还有一类数据类型，被称作资源。

Bevy 中的 资源（Resources） 是用于管理全局唯一数据的核心工具。它们与ECS相辅相成，但扮演着截然不同的角色。为了让各位快速建立直观印象，我们先通过一个表格来对比资源与实体的核心区别。

特性	资源 (Resources)	ECS
数据范围	全局唯一，应用级别	多个实例，附着于单个实体
典型用途	游戏时钟、全局配置、输入状态、资产服务器	玩家位置、敌人血量、武器属性
访问方式	`Res<T>`（只读）, `ResMut<T>`（可写）	`Query<&T>`（只读）, `Query<&mut T>`（可写）
设计初衷	管理共享状态和服务	描述独立对象的属性和行为

在Bevy的DefaultPlugins中，我们已经得到了很多开箱即用的内置资源，其中最典型的有这些：

资源类别	代表性资源	主要用途
时间管理	`Time`	提供时间信息，如帧间隔时间（`delta_seconds`）、自启动后的时间等，用于动画和逻辑更新。
输入处理	`ButtonInput<KeyCode>`	键盘按键状态（`pressed`, `just_pressed`, `just_released`）。
	`ButtonInput<MouseButton>`	鼠标按键状态。
	`Touches`	触摸输入信息，适用于移动设备。
窗口管理	`Windows`	管理所有窗口的属性，如分辨率、标题等。
资产管理	`AssetServer`	用于异步加载外部资源，如图片、声音、模型等。
渲染相关	`ClearColor`	设置窗口的清除颜色（背景色）。

以前面的代码为例，让我们尝试通过资源Time控制HelloPlugin的问候频率，让它不再每帧都问候，而是每两秒问候一次。

需要注意的是，我们是无法直接通过Time完成定时操作的，Time的主要功能除了获取程序运行时间、获取与上一帧间隔时间外主要就是控制游戏运行速度。

不过，好在Bevy中为我们提供了一个可以用于快捷计时的工具类型：Timer。只是，Timer并不是一个资源类型，我们可以将其包装为自定义资源或者作为某个实体的组件去完成任务，考虑到我们现在在讲资源，我就将它包装成资源了。

我们先在hello_plugin.rs中将Timer包装成我们的自定义资源。

#[derive(Resource)]		//通过derive将结构体定义为资源
struct HelloTimer(Timer);

然后，让我们回过头改写hello_plugin.rs旧有代码。我们需要改写的地方一共有两处：

//第一处
impl Plugin for HelloPlugin {
    fn build(&self, app: &mut App) {
        app		//通过insert_resource将我们的自定义资源HelloTimer实例化并挂载到Bevy App上
            .insert_resource(HelloTimer(Timer::from_seconds(2.0, TimerMode::Repeating)))
            .add_systems(Startup,add_people)
            .add_systems(Update,hello_people);	//这里把hello_world去掉
    }
}

//第二处
//通过依赖注入参数类型Res<>与ResMut<>引入Time与我们的自定义资源HelloTimer
fn hello_people(time: Res<Time>, mut timer: ResMut<HelloTimer>,query: Query<&Name, With<Person>>) {
    //若Timer的计时没有完成，则就提前结束函数，不打印问候
    if !timer.0.tick(time.delta()).just_finished(){
        return;
    }
    for name in query.iter() {
        println!("{}，NMSL！！", name.0);
    }
}

完成更改后，点击运行，你会发现“Hello World”不再显示，而问候木冲二÷变成两秒一跳了。

那么，我们为什么要把hello_world从HelloPlugin的build中去掉呢？

因为留着很麻烦啊。

要是同时给hello_people和hello_world都引入HelloTimer，那由于两个都是以可读写引用ResMut<>形式传入，受Rust所有权规则的限制，同一时间只能有一个可变引用。Bevy 的调度器为了保证内存安全，会阻止需要可变访问同一资源的System并行运行。这意味着：hello_world和 hello_people无法在同一帧执行。由于chain()排序hello_world在hello_people前，那几乎等同于hello_people永远也无法在计时器完成那一帧运行，等于是不会再输出了。

要是不给hello_world引入HelloTimer呢？那hello_world会每帧输出，让你根本不好观察hello_people的情况。

要是给hello_world也自定义一个Timer资源呢？这倒能解决问题，但没必要，还是把hello_world去了算了。

——大伙以后开发时要记得Bevy的资源是一个全局唯一的数据类别，由于Rust语言本身和Bevy调度器设计影响，同一时间只能有一个System持有其可读写引用(ResMut)。

现在，既然我们对资源与插件也有了初步的了解与实践，接下来我们可以讨论下游戏窗口，然后正式开始进入游戏开发的初步实战了。

4.4 游戏窗口

让我们把hello_plugin相关的内容全删掉，只保留main.rs

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .run();
}

然后点击运行，我们将得到一个空白的窗口，像这样：

这个窗口就是我们开发者创作的内容和玩家们交互的核心。也是我们真正通过Bevy开发出可玩游戏的起点，而在此之前，请允许我先向你介绍如何对这个窗口进行配置。顺便也让各位了解下如何对DefaultPlugins中的内容进行设置和调整。

首先让我们尝试更改标题。

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(
            WindowPlugin{
                primary_window: Some(Window {
                    title: "我的第一个bevy游戏".to_string(),	//自定义标题
                    ..default()
                }),
                ..default()
            }
        ))
        .run();
}

结果如下：

你可能有些疑惑：怎么改个标题，代码突然多了这么一大坨玩意？

让我们一条条捋。

DefaultPlugins.set()：这是DefaultPlugins的替换设置，用于将你自己实例化的插件替换掉DefaultPlugins内的对应类型插件的默认实例。在这里，我们用自己创建的新的WindowPlugin实例替换掉了DefaultPlugins中默认的WindowPlugin实例。而WindowPlugin就是负责绘制游戏窗口的插件。
primary_window：WindowPlugin插件的主窗口实例及相关设置，类型为Option<Window>。
..default()：rust的语法糖，用于创建实例时用，意思是“对于当前结构体中我没有明确指定的字段，请使用其默认值”，使用它主要是WindowPlugin与Window里存在着大量我们暂时没必要关心和改动的字段。

所以，这些多出来的代码本质是因为：为了设置标题，我们需要自己实例化一个WindowPlugin替换掉DefaultPlugins里的WindowPlugin，而为了使得我们自己实例化的WindowPlugin能做到按我们自己设定的字符更改标题，我们得自己实例化一个title值为设定标题的Window去替代我们自己实例化的WindowPlugin的默认primary_window。

好吧，听起来还是很麻烦，按理说游戏标题这种东西其实是完全可以设计成通过工程配置文件设置的。发生这种情况主要是Bevy目前还处在比较早期的阶段，这个等BSN和Bevy编辑器出来应该会得到改变。现阶段我们只是通过这个来学习如何通过代码对DefaultPlugins中的内容进行自定义。

一般来说，我们能通过Window进行如下设置：

配置类别	关键属性	常用值 / 类型	主要作用
基础属性	`title`	`String`	设置窗口标题栏文字
	`resolution`	`(f32, f32).into()`	设置窗口初始分辨率（宽, 高）
外观与控制	`decorations`	`bool`	是否显示窗口边框和标题栏
	`mode`	`WindowMode`	窗口模式：`Windowed`, `Fullscreen`等
	`enabled_buttons`	`EnabledButtons`	控制最大化、最小化、关闭按钮是否可用
行为与性能	`present_mode`	`PresentMode`	呈现模式：`AutoVsync`（垂直同步）, `AutoNoVsync`等
	`resizable`	`bool`	是否允许用户调整窗口大小
	`cursor`相关	`visible`, `grab_mode`等	控制光标可见性、抓取模式等

Bevy支持多窗口，方式是通过Commands::spawn()将Window另外实例化

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(
            WindowPlugin{
                primary_window: Some(Window {
                    title: "我的第一个bevy游戏".to_string(),
                    ..default()
                }),
                ..default()
            }
        ))
        .add_systems(Startup,create_second_window)	//将函数挂载在Startup
        .run();
}

//生成一个初始大小为640*480的额外窗口
fn create_second_window(mut commands: Commands) {
    commands.spawn(Window{
        title: "第二窗口".to_string(),
        resolution: (640, 480).into(),
        ..default()
    });
}

结果如图：

需要注意的是，这两个窗口是平级的，你需要关掉全部的两个窗口才能结束游戏进程。

如果你希望在主窗口关闭的那一刻就立刻结束游戏进程，那你就得通过监听窗口关闭事件实现：

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(
            WindowPlugin{
                primary_window: Some(Window {
                    title: "我的第一个bevy游戏".to_string(),
                    ..default()
                }),
                ..default()
            }
        ))
        .add_systems(Startup,create_second_window)
        .add_systems(Update, close_game_on_primary_window_closed) //将监听函数挂载到Update
        .run();
}

/// 该系统在检测到主窗口的关闭请求时，退出应用程序
fn close_game_on_primary_window_closed(
    mut close_events: MessageReader<WindowCloseRequested>, // 1. 使用 MessageReader 读取事件
    primary_windows: Query<(), With<PrimaryWindow>>,       // 2. 查询主窗口
    mut app_exit: MessageWriter<AppExit>,                 // 3. 使用 MessageWriter 发送退出事件
) {
    for event in close_events.read() { //如果监听到了窗口关闭事件
        // 判断触发关闭事件的窗口是否为主窗口
        if primary_windows.get(event.window).is_ok() {
            println!("主窗口已关闭，退出游戏。");
            app_exit.write(AppExit::Success); // 发送退出事件
            break; // 通常找到一个主窗口关闭事件后即可退出循环
        }
    }
}

现在，让我们再点击运行，当你关闭主窗口时，另一个窗口将同时关闭，游戏进程也将结束。

对于Bevy基础功能的介绍到这里就结束了，让我们正式进入实践。

5. 启程！开始尝试第一个游戏

接下来，让我们利用刚学习的知识，通过bevy去制作一款简单的2D俯视角射击游戏。

5.1. 素材准备

接下来让我们准备游戏素材，通常来说游戏素材会包括图形、音乐、动画等各种东西。但这次我们只准备图形和音乐。

我们先在项目中新建存放素材的文件夹。Bevy 通过 AssetServer加载资源（如音频、图片、场景等），而 AssetServer的资源搜索路径由 AssetPlugin管理。默认情况下，AssetPlugin会包含项目根目录下的 **assets**文件夹（全小写）。除此之外，你也可以通过Bevy App的add_asset_folder()手动添加你自己的资源路径。

这里我们就懒得再去自定义了，直接在项目下新建一个assets文件夹即可。

图形方面，由于这只是个简单的示例，并不需要复杂的图案，因此我打算使用简单的svg矢量图替代。

然而，Bevy虽然具备高性能得处理和渲染图片的能力，也支持png、jpg(jpeg)等许多通用图片文件格式，但并不支持svg。bevy社区中倒是有诸如bevy_svg和bevy_vello这类的插件以提供svg支持，可在我写文的这个时间点，这些插件还没有跟进0.17版本的支持。

所以这里，我会将SVG转为png作为游戏素材。

如果你还不了解什么是svg，我可以这里跟你简单介绍下：

SVG，可缩放矢量图形（Scalable Vector Graphics），是一种用于描述二维图形的 XML 标记语言。

与位图图像不同，SVG 图像以文本形式存储，并且可以缩放到任意大小而不会失真，因为它们基于数学描述而不是像素。

简单来说，这是一种靠代码描述图案的技术，你可以用xml去描述图案的样式与形状，再由程序去实时绘制。由于它不是供完整图案而是绘制指令，因此它可以随意缩放没有任何清晰度上的损失。现在svg广泛应用于互联网图标等领域。

对svg感兴趣的话可以去看看这个：https://www.runoob.com/svg/svg-example.html ，这里我们先回归到我们的游戏。

我们先制作我们的玩家角色图案，在asset/img文件夹下新建一个player.svg文件，将如下代码复制放入文件中：

<?xml version="1.0" encoding="UTF-8"?>
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
    <path fill="white" fill-rule="evenodd" stroke="black" stroke-width="1"
        d="M 50 0 L 10 60 L 19.603 60 
        A 32 32 0 0 1 80.397 60 L 90 60 Z"/>
    <circle stroke="white" stroke-width="16" fill-opacity="0"
        cx="50" cy="70" r="20"/>
    <circle stroke="black" stroke-width="1" fill-opacity="0"
        cx="50" cy="70" r="12"/>
    <circle stroke="black" stroke-width="1" fill-opacity="0"
        cx="50" cy="70" r="28"/>
</svg>

结果如图：

好了，这个抽象的三角+圆环嵌合体就是我们的“主角”了（你也可以根据自己喜好去定制）。

将图片素材通过免费转换网站转为png后，我们接着准备音乐。

我们将准备两个BGM，分别用于标题画面和战斗画面，BGM可以找网络素材或者用ai生成。

注意：

有些ai生成的mp3文件通过bevy直接读取有报错的风险，推荐先通过免费的格式转换网站或者ffmpeg将文件格式转换为ogg格式。

现在，万事具备，正式开始我们的游戏编码吧。

5.2. 显示图案、播放音乐

正式动工的第一步：先将我们的窗口定好。将音乐与图片展示出来。

我们先设定游戏窗口。

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(
            WindowPlugin{
                primary_window: Some(Window {
                    title: "几何体战争".to_string(),//自定义标题
                    resolution: (1600, 900).into(),//初始宽高
                    ..default()
                }),
                ..default()
            }
        ))
        .run();
}

然后，让我们通过一个自定义的函数setup()加载图案与音乐（同时播放），并将其挂载到Bevy App上

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(/*……此略*/)
        .add_systems(Startup, setup)	//将setup挂载至Bevy App
        .run();
}

///自定义的加载函数
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    //加载主题音乐
    let theme_music: Handle<AudioSource> = asset_server.load("audio/Theme.ogg");
    //加载玩家图案
    let player_img: Handle<Image> = asset_server.load("img/player.png");


    commands.spawn(Camera2d);//新建一个2D相机，作为游戏窗口视角画面源
    commands.spawn(AudioPlayer::new(theme_music));//创建一个AudioPlayer来播放音乐
    commands.spawn(Sprite::from_image(player_img));//创建一个Sprite来显示图案

}

点击运行，你将得到如图所示的窗口，窗口中有我们主角的图像，并在打开的那一刻立刻播放我们的主题乐：

同样的，让我们先了解一下这里面的一些概念：

camera：直译是“相机”，但在游戏里，它通常表示的是“视角”。这是一个3D游戏流行后才广泛起来的概念，用于解决「将游戏世界的哪一部分渲染到屏幕上」的问题

AssetServer：Bevy种负责异步加载和管理所有资源（图片、音频、模型等）的中心服务。

Handle<T>：一个指向资源的智能指针，它通常和AssetServer搭配使用，主要原因是它对异步友好，可以即时返回而无需等待资源加载完成。而且，Handle还有另一个优点是允许资源共享，多个实体可以使用同一个资源的Handle。

AudioPlayer与Sprite：分别是音乐播放和图片显示组件，可以和其他组件组合构建功能更全面的实体。

接下来，让我们想办法让我们的角色动起来。

5.3. 第一个角色

其实，到现在为止，我们有的都只是一个图像，而不是一个角色——因为一个角色是不可能只有图像的，它必然还包括状态和行为，而状态中最基本的就是位置状态。

让我们为我们的玩家角色设立一个Entity。

#[derive(Component)]
struct Player;

impl Player {
    // 这是一个"构建器方法"，允许我们在实体之间重用逻辑
    // 使代码更易读，且在更改逻辑时减少错误
    // 注意这里同时打包 Player、Sprite 和 Transform 组件，覆盖了必需组件的默认值
    fn new(img: Handle<Image>) -> (Player,Sprite,Transform) {
        (
            Player,
            Sprite::from_image(img),
            //Transform是用于表示角色在游戏世界位置与缩放状态的组件
            //虽然是2D游戏，但Z坐标有助于图片遮挡关系排序
            Transform::from_xyz(0.0, 0.0, 1.0),
        )
    }
}

好了，这个Player::new()就是我前面提到的，通过标记性组件（即类型名称组件）将实体一次性打包的办法了，这个方法直接返回了一个包含着整个实体所有组件的元组。

所以我们在setup中实例化一个玩家实体只需要这样：

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    //……前略
    commands.spawn(Camera2d);
    commands.spawn(AudioPlayer::new(theme_music));
    
    //这里我们将Sprite的实体化给注释掉
    //commands.spawn(Sprite::from_image(player_img));
    
    commands.spawn(Player::new(player_img));//将玩家角色及其所需组件一次性打包实例化为一个实体

}

接下来，让我们控制他移动。

首先，我们的角色需要一个表示移动速度的组件：

///角色移动速度
#[derive(Component)]
struct Speed(f32);

//对Player的new()进行修改，将Speed加入实体Player的组件集中
impl Player {
    fn new(img: Handle<Image>) -> (Player,Sprite,Transform,Speed) {
        (
            Player,
            Sprite::from_image(img),
            Transform::from_xyz(0.0, 0.0, 1.0),
            Speed(100.0),	//这里暂定一个100，你可以根据自己需要调整数值
        )
    }
}

然后，简单地写一个处理玩家移动的函数：

//处理玩家角色移动
fn player_move(
    key: Res<ButtonInput<KeyCode>>,		//通过ButtonInput资源获取键盘输入
    player_s: Single<(&mut Transform, &Speed), With<Player>>,	//获取玩家的位置与速度
    time: Res<Time>,	//获取时间
){
    let (mut transform, speed) = player_s.into_inner();
    //移动控制
    if key.pressed(KeyCode::KeyW){
        //time.delta()获取这一帧到上一帧的时间差
        transform.translation.y+= speed.0 * time.delta_secs();
    }
    if key.pressed(KeyCode::KeyS){
        transform.translation.y-= speed.0 * time.delta_secs();
    }
    if key.pressed(KeyCode::KeyD){
        transform.translation.x += speed.0 * time.delta_secs();
    }
    if key.pressed(KeyCode::KeyA){
        transform.translation.x -= speed.0 * time.delta_secs();
    }
}

最后，将这个函数挂载到Bevy App的Update调度集上

fn main() {
    App::new()
        //前略
        .add_systems(Update, player_move)	//将setup挂载至Bevy App
        .run();
}

现在，当你点击运行并按动键盘的W、S、A、D键时，你的玩家图案就会发生移动。

1.Single<>是什么？

Single<>是对Query<>的一层封装，相当于直接Query<>::single()，免去了将Query<>集合拆开的麻烦。你只能在确信你要获取的实体有且只有一个实例时使用它，否则它会导致错误。在这里，我们的玩家是唯一的。

2.为什么图片移动时，步进距离是speed.0 * time.delta_secs(),而不直接用speed.0？

time.delta_secs()获取的是调度集这一轮调度到上一轮调度的时间差（以秒为单位尺度），由于Update每帧调度一次，因此这里基本就是每帧的时间差。举个例子，假设游戏在当前帧fps为50，则意味着该帧到上一帧的时间差为20ms，即0.02s，因此这个time.delta_secs()返回值为0.02。

在此处我们使用这个间隔值乘角色移速作为最终步进量，主要原因有两个：①使游戏逻辑内速度不受当前帧率影响而发生波动；②以秒为单位时间尺度，设定速度值更方便。

5.4. 移动调优和面向鼠标

不知道你在之前测试移动时有没有发现一件事情。那就是物体在x、y两根轴上的移动都是单独计算的，这意味着物体在斜向运动时，由于x、y两轴速度都是speed，其实物体实际速度其实是 √2 * speed 。

这明显不合理，让我们纠正它，修改移动函数。

fn player_move(
    key: Res<ButtonInput<KeyCode>>,
    player_s: Single<(&mut Transform, &Speed), With<Player>>,
    time: Res<Time>,
){
    let (mut transform, speed) = player_s.into_inner();
    //建立一个用于表示移动方向的向量
    let mut velocity = Vec2::ZERO;
    //获取键盘输入后不再直接修改transform
    if key.pressed(KeyCode::KeyW){
        velocity.y+= 1.0;
    }
    if key.pressed(KeyCode::KeyS){
        velocity.y-= 1.0;
    }
    if key.pressed(KeyCode::KeyD){
        velocity.x += 1.0;
    }
    if key.pressed(KeyCode::KeyA){
        velocity.x -= 1.0;
    }
    //向量归一化（0向量则保持零）并乘上步进距离，以获取真实的物体在x、y上的速度
    velocity = velocity.normalize_or_zero() * speed.0 * time.delta_secs();
    //将x、y两轴的移动量累加在物体位置上。
    transform.translation.x += velocity.x;
    transform.translation.y += velocity.y;
}

这样速度就在各方向上统一了。

接下来我们尝试让我们的玩家角色朝向鼠标位置（以为后续射击玩法做准备）。

我们先获取鼠标位置。

fn forward_cursor(
    //获取相机和相机位置
    camera_s: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
    //获取主窗口
    window_s: Single<&Window, With<PrimaryWindow>>,
){
    let (camera, global) = camera_s.into_inner();
    //通过主窗口得到玩家在鼠标在窗口内的位置
    let mouse_pos_op: Option<Vec2> = window_s.cursor_position();
    //如果鼠标不在窗口内，则提前退出函数
    if mouse_pos_op.is_none(){
        return;
    }
    //转换为游戏空间位置
    let mouse_pos = camera.viewport_to_world_2d(&global, mouse_pos_op.unwrap()).unwrap();
    //通过控制台输出测试获取的位置是否正确。
    println!("{}", mouse_pos);
}

然后我们可以将这个函数挂载到Update调度集上测试。

测试没问题的话，接下来我们将让玩家角色转向我们鼠标的位置。

fn forward_cursor(
    camera_s: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
    //引入玩家位置
    player_s: Single<&mut Transform, With<Player>>,
    window_s: Single<&Window, With<PrimaryWindow>>,
){
    let (camera, global) = camera_s.into_inner();
    let mut transform = player_s.into_inner();
    let mouse_pos_op = window_s.cursor_position();
    if mouse_pos_op.is_none(){
        return;
    }
    let mouse_pos = camera.viewport_to_world_2d(&global, mouse_pos_op.unwrap()).unwrap();
    //得出玩家到鼠标的方向
    let direction = mouse_pos - transform.translation.truncate();
    //计算旋转角度，因为我的图案角色默认状态是指向正上方的，因此这里我用Y轴正方向作为角度计算起始方向
    let angle = Vec2::Y.angle_to(direction);
    //应用旋转
    transform.rotation = Quat::from_axis_angle(Vec3::Z, angle);
}

再度点击运行，你会发现，当你鼠标位于窗口内时，玩家角色的箭头将始终指向你的位置，无论你如何移动。

我们并没有为Camera2d所属实体引入Camera与GlobalTransform组件，为什么Single<>能查询到实例？

这与Camera2d的特点相关，Camera2d 是一个简单的标记组件，专门用于2D渲染，本身并没有数据。但是，就像我们自己定义的Player一样，Camera2d在被Command::spawn()实例化时同样会在所属实体中自动添加Camera、Projection、Frustum、GlobalTransform等等一系列2D相机所需的数据，不同的是它并不通过new()打包去实现这一点，而是通过Bevy的RequiredComponents机制使其自动插入。

想进一步了解RequiredComponents机制的话可以去查询官方文档：https://docs.rs/bevy/latest/bevy/prelude/trait.Component.html#method.register_required_components

未完待续