企业官网建设流程全解析

1. 项目概述与核心思路

几年前，当我第一次尝试用C++写一个能跑起来的游戏时，那感觉就像试图用螺丝刀组装一台电脑——你知道每个零件大概有什么用，但真动起手来，到处都是线头，一通电就冒烟。后来，我花了大量时间在引擎底层和图形API上折腾，才慢慢摸清了门道。今天，我想带你走的，是一条更清晰、更务实的路：用C++和SFML库，从零开始构建一个完整的2D俯视角射击游戏。这个项目不追求炫酷的3A级画面，而是聚焦于游戏开发中最核心的几根“大梁”：游戏循环、实体管理、碰撞检测、输入处理和状态管理。通过亲手搭建这些模块，你能透彻理解一个游戏是如何“活”起来的，这份底层认知是使用Unity、Unreal等成熟引擎时难以获得的宝贵财富。

这个实战项目适合谁？如果你已经掌握了C++的基础语法（类、继承、STL容器），对面向对象编程有初步了解，并且怀揣着“自己动手做游戏”的热情，那么这就是为你准备的。我们将从创建一个空窗口开始，一步步添加玩家、敌人、子弹、碰撞和分数，最终得到一个可玩、可扩展的游戏原型。整个过程，我会穿插大量“我踩过的坑”和“为什么这么做”的讲解，让你知其然，更知其所以然。

2. 开发环境搭建与工具选型

工欲善其事，必先利其器。选择一套顺手、稳定的开发环境，能让你在后续编码中少踩很多坑。

2.1 集成开发环境（IDE）的选择

主流选择有两个：Visual Studio 2022和VSCode + CMake。它们各有优劣，我的建议是：

• Visual Studio 2022 (Community版)：对Windows平台的C++开发者来说是“开箱即用”的王者。它集成了强大的调试器、直观的项目管理器和NuGet包管理器。对于新手，特别是被“配置环境”劝退过的朋友，我强烈推荐从这个开始。它的“一键编译调试”体验能让你更专注于代码逻辑，而不是构建脚本。
• VSCode + CMake + MinGW：这套组合更轻量、跨平台，配置过程本身也是对现代C++项目构建流程的一次很好学习。如果你未来打算进行跨平台开发（比如发布到Linux），或者希望更深入地控制构建流程，这是更好的选择。不过，初期配置插件（C/C++、CMake Tools）和编写CMakeLists.txt文件会多花一些时间。

我的实操心得：如果你是第一次做C++游戏项目，无脑选Visual Studio 2022。把有限的精力集中在游戏逻辑上，而不是和环境搏斗。等项目跑起来了，你对整个流程熟悉了，再尝试VSCode+CMake来深化理解也不迟。

2.2 图形与多媒体库：为什么是SFML？

C++标准库没有提供图形、音频、窗口管理等功能，因此我们必须借助第三方库。SDL2和SFML是两个最流行的2D游戏开发库。

我选择SFML（Simple and Fast Multimedia Library）的原因如下：

1. 面向对象的设计：SFML的API是纯面向对象的（如sf::RenderWindow,sf::Sprite,sf::Sound），对于正在学习OOP的C++开发者来说，概念映射更直接，代码写起来更“C++风格”。
2. 模块化与易用性：它被清晰地分为Graphics（图形）、Window（窗口）、Audio（音频）、Network（网络）等模块，你可以只链接需要的部分。其API设计简洁直观，通常几行代码就能打开一个窗口并绘制图形。
3. 良好的文档与社区：官方文档和教程非常完善，社区活跃，遇到问题容易找到解决方案。
4. 性能足够：对于我们要做的2D射击游戏，以及绝大多数2D游戏，SFML的性能绰绰有余。

安装SFML（以Visual Studio 2022为例）：

1. 访问 SFML官网 下载页面。
2. 选择与你的Visual Studio版本和系统架构匹配的包。例如，对于VS2022，通常选择 “Visual C++ 17 (2022) - 64-bit” 的“GCC”预编译包（注意：SFML官网的“Visual C++”指的是编译器版本，而非IDE，选择对应你VS里编译器版本的即可。VS2022对应VC++17）。
3. 下载后解压到一个没有中文和空格的路径，比如D:\Libraries\SFML-2.6.0。
4. 在Visual Studio中配置项目属性：
   • C/C++ -> 常规 -> 附加包含目录：添加SFML的include文件夹路径（如D:\Libraries\SFML-2.6.0\include）。
   • 链接器 -> 常规 -> 附加库目录：添加SFML的lib文件夹路径（如D:\Libraries\SFML-2.6.0\lib）。
   • 链接器 -> 输入 -> 附加依赖项：根据你的构建配置（Debug/Release）添加需要的库文件。通常Debug模式需要加-d后缀。例如，对于Debug配置，你可能需要添加：sfml-graphics-d.lib; sfml-window-d.lib; sfml-system-d.lib; sfml-audio-d.lib;。Release配置则去掉-d后缀。
5. 最后，将SFML的bin文件夹路径（如D:\Libraries\SFML-2.6.0\bin）添加到系统的PATH环境变量，或者将DLL文件复制到你的项目可执行文件（.exe）所在的目录。

2.3 资源管理：纹理、音效与字体

游戏离不开图像和声音。我们需要提前准备一些资源：

• 玩家/敌人/子弹纹理：可以是简单的几何图形（用SFML的sf::RectangleShape或sf::CircleShape绘制），也可以从OpenGameArt等网站找一些免费的像素艺术素材。建议尺寸为32x32或64x64像素，格式为PNG（支持透明）。
• 音效：射击声、爆炸声、被击中声。同样可以在免费资源站找到，格式推荐WAV或OGG。
• 字体：用于显示分数、生命值等UI信息。SFML支持TrueType字体（.ttf）。

在项目目录下创建一个assets文件夹，里面再分textures、sounds、fonts子文件夹，把资源分门别类放好。这是一种良好的工程习惯。

3. 游戏引擎核心架构设计

在写第一行游戏逻辑代码之前，我们必须先想清楚整个程序的结构。一个典型的、易于维护的游戏循环架构如下：

游戏主循环 (Game Loop) | |-- 处理输入 (Process Input) |-- 更新游戏状态 (Update Game State) | |-- 更新所有实体 (玩家、敌人、子弹...) | |-- 检测碰撞 | |-- 处理游戏逻辑（得分、生命、胜负条件） | |-- 渲染 (Render) |-- 清屏 |-- 绘制所有可见实体 |-- 绘制UI |-- 显示到窗口

我们将用面向对象的思想来实现这个架构。核心类包括：

1. Game类：游戏的“总指挥”，负责管理窗口、运行主循环、持有和管理所有游戏状态和实体。
2. Entity基类：所有游戏内可交互对象（玩家、敌人、子弹、道具）的抽象基类。它应该包含位置、速度、生命值等通用属性，以及update()和render()虚函数。
3. 派生实体类：Player,Enemy,Bullet等，继承自Entity，实现各自特定的逻辑。
4. ResourceManager类（可选但推荐）：一个简单的资源管理器，负责加载和缓存纹理、字体、音效，避免重复加载。

3.1 实现Game类与主循环

让我们从Game类开始。它的核心是一个run()方法，里面包裹着经典的游戏主循环。

// Game.hpp #pragma once #include <SFML/Graphics.hpp> #include <vector> #include <memory> #include "Entity.hpp" class Game { public: Game(); void run(); private: void processEvents(); void update(sf::Time deltaTime); void render(); sf::RenderWindow mWindow; sf::Time mTimePerFrame; // 控制每帧时长，用于固定时间步长更新 std::vector<std::unique_ptr<Entity>> mEntities; // 使用智能指针管理实体 // ... 其他成员，如玩家指针、分数、游戏状态等 };

// Game.cpp (部分关键代码) Game::Game() : mWindow(sf::VideoMode(1024, 768), "C++ 2D射击游戏") , mTimePerFrame(sf::seconds(1.f / 60.f)) // 目标帧率60FPS { // 初始化资源、创建玩家实体等 mPlayer = std::make_unique<Player>(...); mEntities.push_back(std::move(mPlayer)); } void Game::run() { sf::Clock clock; sf::Time timeSinceLastUpdate = sf::Time::Zero; while (mWindow.isOpen()) { // 计算上一帧到这一帧经过的时间 sf::Time deltaTime = clock.restart(); timeSinceLastUpdate += deltaTime; // 固定时间步长更新：确保物理和逻辑更新与帧率解耦，避免不同性能电脑上游戏速度不同。 while (timeSinceLastUpdate > mTimePerFrame) { timeSinceLastUpdate -= mTimePerFrame; processEvents(); update(mTimePerFrame); // 传入固定的时间步长 } render(); // 渲染可以以可变帧率进行，让画面更流畅 } } void Game::update(sf::Time deltaTime) { // 1. 更新所有实体 for (auto& entity : mEntities) { if (entity->isAlive()) { entity->update(deltaTime); } } // 2. 碰撞检测（稍后实现） // 3. 清理死亡实体（“擦除-移除”惯用法） mEntities.erase( std::remove_if(mEntities.begin(), mEntities.end(), [](const std::unique_ptr<Entity>& e) { return !e->isAlive(); }), mEntities.end()); // 4. 生成新敌人等逻辑 }

核心原理与避坑指南：这里使用了固定时间步长（Fixed Timestep）的游戏循环。deltaTime是真实流逝的时间，我们累积它，一旦超过预设的固定时间片（如1/60秒），就执行一次update。这样做的好处是，无论电脑快慢，update中模拟的游戏世界时间都是以固定速度前进的，物理计算更稳定。而render渲染则可以在每次主循环中都执行，以利用高刷新率显示器，这就是所谓的“渲染快于更新”。

3.2 设计Entity基类与派生类

Entity类是所有游戏对象的基石。

// Entity.hpp #pragma once #include <SFML/Graphics.hpp> class Entity { public: Entity(float x, float y); virtual ~Entity() = default; virtual void update(sf::Time deltaTime) = 0; // 纯虚函数，子类必须实现 virtual void render(sf::RenderWindow& window) = 0; sf::Vector2f getPosition() const { return mPosition; } void setPosition(sf::Vector2f pos) { mPosition = pos; } sf::FloatRect getBoundingBox() const; // 用于碰撞检测的边界框 bool isAlive() const { return mIsAlive; } void destroy() { mIsAlive = false; } protected: sf::Vector2f mPosition; sf::Vector2f mVelocity; bool mIsAlive = true; // ... 其他通用属性，如图形对象(sf::Sprite)、生命值等 };

然后，我们实现具体的Player类。玩家需要响应键盘输入。

// Player.hpp #pragma once #include "Entity.hpp" class Player : public Entity { public: Player(float x, float y); void update(sf::Time deltaTime) override; void render(sf::RenderWindow& window) override; void handleInput(); // 处理键盘输入 private: float mMoveSpeed; sf::Sprite mSprite; // ... 玩家特有属性，如射击冷却、生命值 };

// Player.cpp void Player::handleInput() { mVelocity.x = mVelocity.y = 0; // 每帧先重置速度 if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)) mVelocity.y = -mMoveSpeed; if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)) mVelocity.y = mMoveSpeed; if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)) mVelocity.x = -mMoveSpeed; if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)) mVelocity.x = mMoveSpeed; // 归一化对角线移动速度，避免斜向移动更快 if (mVelocity.x != 0 && mVelocity.y != 0) { mVelocity *= 0.7071f; // 近似 1/sqrt(2) } } void Player::update(sf::Time deltaTime) { handleInput(); // 根据速度和帧时间更新位置 mPosition += mVelocity * deltaTime.asSeconds(); // 简单的屏幕边界检查 mPosition.x = std::max(0.f, std::min(mPosition.x, 1024.f - mSprite.getGlobalBounds().width)); mPosition.y = std::max(0.f, std::min(mPosition.y, 768.f - mSprite.getGlobalBounds().height)); // 更新精灵位置 mSprite.setPosition(mPosition); }

4. 核心游戏机制实现

有了骨架，现在我们来填充血肉，实现射击游戏最激动人心的部分：射击、碰撞和敌人生成。

4.1 射击系统：子弹的生成与管理

射击的本质是：当玩家按下射击键（如空格）时，在玩家的位置（或枪口位置）创建一个Bullet实体，并赋予它一个朝向（比如鼠标方向）的速度。

首先，在Player类中添加射击相关的逻辑：

// Player.hpp 新增 #include "Bullet.hpp" #include <SFML/System/Time.hpp> class Player : public Entity { // ... void shoot(sf::Vector2f targetPosition); // 向目标位置射击 bool canShoot() const; void update(sf::Time deltaTime) override; private: sf::Time mShootCooldown; sf::Time mTimeSinceLastShot; // ... };

// Player.cpp void Player::update(sf::Time deltaTime) { // ... 原有的移动处理 mTimeSinceLastShot += deltaTime; // 处理射击输入（例如，鼠标左键或空格键） if (sf::Mouse::isButtonPressed(sf::Mouse::Left) && canShoot()) { // 获取鼠标在游戏世界中的坐标（需要将窗口坐标转换为视图坐标） sf::Vector2i mousePixelPos = sf::Mouse::getPosition(mWindow); // 需要Game类传递窗口引用或使用其他方式 sf::Vector2f worldPos = mWindow.mapPixelToCoords(mousePixelPos); shoot(worldPos); } } void Player::shoot(sf::Vector2f targetPosition) { if (!canShoot()) return; sf::Vector2f direction = targetPosition - mPosition; // 归一化方向向量，并乘以子弹速度 float length = std::sqrt(direction.x * direction.x + direction.y * direction.y); if (length != 0) { direction /= length; } // 假设子弹从玩家中心射出 sf::Vector2f bulletSpawnPos = mPosition + sf::Vector2f(mSprite.getGlobalBounds().width/2, mSprite.getGlobalBounds().height/2); // 创建子弹并添加到游戏实体列表中（需要Game类提供添加实体的接口） // 例如：game.spawnBullet(std::make_unique<Bullet>(bulletSpawnPos, direction * 500.f)); mTimeSinceLastShot = sf::Time::Zero; // 重置冷却计时 }

Bullet类的实现相对简单，主要是在update中根据速度移动，并检查是否飞出屏幕边界（飞出则destroy()自己）。

4.2 碰撞检测：让游戏世界产生交互

碰撞检测是游戏逻辑的“裁判”。我们采用轴对齐包围盒（AABB）检测，因为它计算简单高效，非常适合2D射击游戏中的矩形或近似矩形的物体。

在Entity基类中，我们已经定义了getBoundingBox()方法来获取实体的边界框（一个sf::FloatRect）。SFML的sf::FloatRect类有一个方便的intersects方法用于检测两个矩形是否相交。

我们在Game::update的固定时间步长更新中，加入碰撞检测逻辑。一个简单（但低效）的方法是双重循环遍历所有实体：

void Game::checkCollisions() { for (size_t i = 0; i < mEntities.size(); ++i) { // 只检查活着的实体 if (!mEntities[i]->isAlive()) continue; for (size_t j = i + 1; j < mEntities.size(); ++j) { if (!mEntities[j]->isAlive()) continue; // 获取类型（可以通过RTTI或自定义类型枚举） // 这里假设Entity有getType()方法返回枚举 EntityType typeA = mEntities[i]->getType(); EntityType typeB = mEntities[j]->getType(); if (mEntities[i]->getBoundingBox().intersects(mEntities[j]->getBoundingBox())) { // 发生碰撞，根据类型处理 handleCollision(typeA, typeB, mEntities[i].get(), mEntities[j].get()); } } } } void Game::handleCollision(EntityType a, EntityType b, Entity* entityA, Entity* entityB) { // 玩家与敌人碰撞 if ((a == EntityType::Player && b == EntityType::Enemy) || (a == EntityType::Enemy && b == EntityType::Player)) { static_cast<Player*>(entityA)->takeDamage(1); static_cast<Enemy*>(entityB)->takeDamage(1); // 或者敌人碰到玩家也掉血 } // 子弹与敌人碰撞 else if ((a == EntityType::Bullet && b == EntityType::Enemy) || (a == EntityType::Enemy && b == EntityType::Bullet)) { Entity* bullet = (a == EntityType::Bullet) ? entityA : entityB; Entity* enemy = (a == EntityType::Enemy) ? entityA : entityB; bullet->destroy(); enemy->destroy(); // 增加分数 mScore += 100; } // ... 其他碰撞类型 }

性能优化提示：上述双重循环的复杂度是O(n²)，当实体数量（n）很大时（比如超过几百个），会严重拖慢游戏。在实际项目中，我们需要引入空间分割技术，如四叉树（Quadtree）或网格（Grid），将实体按位置分组，只检查相邻组内的实体碰撞，能极大提升性能。对于初学者项目，实体数量不多时，双重循环是可以接受的，但了解这个优化方向很重要。

4.3 敌人生成与AI（行为树雏形）

没有敌人的射击游戏是没有灵魂的。我们实现一个简单的敌人生成器和最基本的AI。

敌人生成器：可以在Game类中设置一个计时器，每隔几秒在屏幕边缘的随机位置生成一个敌人。

// Game.hpp sf::Time mEnemySpawnTimer; sf::Time mEnemySpawnInterval; // Game.cpp update函数内 mEnemySpawnTimer += deltaTime; if (mEnemySpawnTimer >= mEnemySpawnInterval) { mEnemySpawnTimer -= mEnemySpawnInterval; spawnEnemy(); } void Game::spawnEnemy() { // 在屏幕四边随机选择一个边生成 int side = rand() % 4; float x, y; switch(side) { case 0: x = 0; y = rand() % 768; break; // 左边 case 1: x = 1024; y = rand() % 768; break; // 右边 case 2: x = rand() % 1024; y = 0; break; // 上边 case 3: x = rand() % 1024; y = 768; break; // 下边 } auto enemy = std::make_unique<Enemy>(x, y); mEntities.push_back(std::move(enemy)); }

敌人AI：最简单的AI就是“朝向玩家移动”。在Enemy::update中实现：

void Enemy::update(sf::Time deltaTime) { // 假设能获取到玩家位置（可以通过Game类传递引用或使用全局访问器，这里简化） sf::Vector2f playerPos = Game::getInstance().getPlayerPosition(); sf::Vector2f direction = playerPos - mPosition; float length = std::sqrt(direction.x * direction.x + direction.y * direction.y); if (length > 0) { direction /= length; // 归一化 mVelocity = direction * mMoveSpeed; mPosition += mVelocity * deltaTime.asSeconds(); mSprite.setPosition(mPosition); } // 也可以添加简单的“攻击”逻辑，比如靠近到一定距离后自爆或发射子弹 }

5. 游戏状态、UI与音效集成

5.1 游戏状态管理

一个完整的游戏至少有开始、进行中、暂停、结束（胜利/失败）几种状态。我们可以用一个枚举来管理。

// Game.hpp enum class GameState { MainMenu, Playing, Paused, GameOver }; class Game { // ... GameState mCurrentState; void handleMainMenuInput(); void handlePlayingInput(); void handlePausedInput(); void updatePlaying(sf::Time deltaTime); void renderMainMenu(); void renderPlaying(); // ... };

在主循环的processEvents和update、render中，根据mCurrentState调用不同的处理函数。例如，在暂停状态下，update函数可能只更新UI动画，而不更新实体逻辑。

5.2 用户界面（UI）绘制

使用SFML的sf::Text和sf::Font来绘制UI。

// 在Game类中加载字体 mFont.loadFromFile("assets/fonts/arial.ttf"); // 创建分数文本 mScoreText.setFont(mFont); mScoreText.setCharacterSize(24); mScoreText.setFillColor(sf::Color::White); mScoreText.setPosition(10, 10); // 在render函数中更新文本内容并绘制 void Game::renderPlaying() { mWindow.clear(); // 绘制所有游戏实体... for (auto& entity : mEntities) { entity->render(mWindow); } // 绘制UI mScoreText.setString("Score: " + std::to_string(mScore)); mWindow.draw(mScoreText); // 绘制生命值等... mWindow.display(); }

5.3 音效集成

音效能极大提升游戏体验。SFML的音频模块使用起来非常直观。

// 在ResourceManager或Game类中加载音效 sf::SoundBuffer shootBuffer; if (!shootBuffer.loadFromFile("assets/sounds/shoot.wav")) { // 处理加载错误 } sf::Sound shootSound; shootSound.setBuffer(shootBuffer); // 在玩家射击时播放 void Player::shoot(...) { // ... 创建子弹的逻辑 shootSound.play(); // 注意：同一个音效对象不能同时播放多次，需要多个实例或使用音效池 }

关于音效管理的经验：直接为每个需要发声的实体创建一个sf::Sound对象在实体销毁时可能会出问题。更好的做法是创建一个音效池（Sound Pool）或使用sf::Music流式播放背景音乐，用sf::Sound播放短促的音效，并管理其生命周期。一个简单的音效池可以维护一组sf::Sound实例，播放时从中找一个空闲的来用。

6. 性能优化、调试与扩展方向

当游戏基本能跑起来后，我们就要关注如何让它跑得更好，以及如何扩展。

6.1 性能优化要点

1. 纹理图集（Texture Atlas）：如果你有很多小纹理（比如子弹、粒子效果），频繁切换纹理（sf::Sprite::setTexture）是昂贵的操作。可以将所有小纹理合并到一张大图上，通过设置纹理矩形（sf::Sprite::setTextureRect）来显示不同部分，这样只需绑定一次纹理。
2. 精灵批处理（Sprite Batching）：SFML本身没有内置的批处理渲染器。但你可以通过sf::VertexArray手动实现，将多个使用相同纹理的精灵的顶点数据合并到一个数组中，然后一次性绘制，这能显著减少Draw Call，提升渲染效率。对于实体数量众多的游戏（如弹幕游戏）是必备优化。
3. 空间分割优化碰撞：如前所述，实现四叉树或网格系统。
4. 对象池（Object Pooling）：对于频繁创建和销毁的对象，如子弹、粒子，不要每次都new/delete。可以预先分配一个对象池，使用时从池中取用，放回时重置状态而非销毁。这能避免内存碎片和频繁的内存分配开销。

6.2 调试技巧

1. 使用SFML的调试视图：sf::RectangleShape可以很方便地绘制碰撞框，帮助可视化调试碰撞检测。

   sf::RectangleShape debugRect(sf::Vector2f(bounds.width, bounds.height)); debugRect.setPosition(bounds.left, bounds.top); debugRect.setFillColor(sf::Color::Transparent); debugRect.setOutlineColor(sf::Color::Red); debugRect.setOutlineThickness(1.f); window.draw(debugRect);

2. 控制台输出：在关键逻辑处使用std::cout输出变量状态（如位置、生命值），但注意发布时要移除或禁用。
3. 利用IDE调试器：熟练使用Visual Studio的断点、监视窗口、调用堆栈，是解决复杂逻辑问题的利器。

6.3 项目扩展方向

一个基础的原型完成后，你可以选择以下方向深入，把它变成一个更丰满的游戏：

• 更多敌人类型：实现移动模式不同的敌人（直线、追踪、环绕、发射子弹的Boss）。
• 武器与升级系统：让玩家可以拾取不同的武器（散弹、激光、导弹），或者升级射速、伤害。
• 粒子系统：为射击、爆炸、引擎尾焰添加简单的粒子效果（用sf::VertexArray模拟）。
• 关卡与波次：设计不同的关卡地图（可以用瓦片地图），敌人按波次出现，难度递增。
• 加入ECS架构：如果你的代码开始变得臃肿，可以研究实体组件系统（Entity-Component-System），这是一种更优雅、更易扩展的游戏架构模式，将数据（组件）、行为（系统）和对象（实体）分离。

7. 常见问题与解决方案速查

在开发过程中，你几乎一定会遇到下面这些问题。这里是我整理的“避坑指南”：

走到这里，你已经拥有了一个由自己亲手搭建的、可以运行和游玩的2D射击游戏核心。这远不止是几行代码的堆砌，你构建的是一个可运行的架构，理解了游戏循环如何驱动世界，实体如何通过组件和行为互动，状态如何管理。这份从零到一的经验，是直接跳入大型游戏引擎所无法给予的。当你下次再用Unity或Godot时，看到场景（Scene）、实体（Entity）、组件（Component）这些概念，你会会心一笑，因为你曾在更底层的地方见过它们最初的模样。

这个项目代码远非完美，但它是一个坚实的起点。我建议你把它上传到GitHub，然后尝试去实现前面提到的扩展方向。每实现一个功能，你都会对游戏开发有更深的理解。编程和做游戏一样，乐趣就在这不断的创造、调试和优化的循环之中。如果在扩展过程中遇到新的问题，回头看看我们搭建的这个基础框架，思考该在哪里修改、如何保持代码的整洁，这本身就是最棒的练习。