020 《C++ 游戏开发 (Game Development) 深度解析》

                                
                                    

                            
1
                            
cmake_minimum_required(VERSION 3.10) # 指定 CMake 最低版本要求
                        

                            
2
                            
project(MyGame) # 项目名称
                        

                            
3
                            

                        

                            
4
                            
add_executable(MyGameApp src/main.cpp src/game.cpp) # 添加可执行文件目标，指定源文件
                        

                            
5
                            

                        

                            
6
                            
target_link_libraries(MyGameApp 
                        

                            
7
                            
    # 添加链接库，例如 SDL2, OpenGL 等
                        

                            
8
                            
    # SDL2::SDL2 
                        

                            
9
                            
    # OpenGL::GL 
                        

                            
10
                            
)
                        

                            
11
                            

                        

                            
12
                            
target_include_directories(MyGameApp PRIVATE 
                        

                            
13
                            
    ${CMAKE_CURRENT_SOURCE_DIR}/include # 添加头文件搜索路径
                        

                            
14
                            
)
                        

                            
15
                            

                        

                            
16
                            
set(CMAKE_CXX_STANDARD 17) # 设置 C++ 标准
                        

                            
17
                            
set(CMAKE_CXX_STANDARD_REQUIRED YES)
                        
                                
                            

                                
                                    

                            
1
                            
int score;        // 声明一个整型变量 score，用于存储玩家得分
                        

                            
2
                            
float playerSpeed;  // 声明一个浮点型变量 playerSpeed，用于存储玩家移动速度
                        

                            
3
                            
bool isGameOver;   // 声明一个布尔型变量 isGameOver，用于表示游戏是否结束
                        

                            
4
                            
std::string playerName; // 声明一个字符串变量 playerName，用于存储玩家姓名
                        
                                
                            

                                
                                    

                            
1
                            
int score = 0;        // 声明并初始化整型变量 score 为 0
                        

                            
2
                            
float playerSpeed = 5.0f; // 声明并初始化浮点型变量 playerSpeed 为 5.0
                        

                            
3
                            
bool isGameOver = false;  // 声明并初始化布尔型变量 isGameOver 为 false
                        

                            
4
                            
std::string playerName = "Player"; // 声明并初始化字符串变量 playerName 为 "Player"
                        

                            
5
                            

                        

                            
6
                            
score = 100;          // 后续赋值
                        

                            
7
                            
playerSpeed = 7.5f;
                        

                            
8
                            
isGameOver = true;
                        

                            
9
                            
playerName = "Guest";
                        
                                
                            

                                
                                    

                            
1
                            
if (condition) {
                        

                            
2
                            
    // 当 condition 为真 (true) 时执行的代码块
                        

                            
3
                            
} else if (condition2) {
                        

                            
4
                            
    // 当 condition 为假 (false) 且 condition2 为真 (true) 时执行的代码块 (可选)
                        

                            
5
                            
} else {
                        

                            
6
                            
    // 当所有条件都为假 (false) 时执行的代码块 (可选)
                        

                            
7
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
if (playerHealth <= 0) {
                        

                            
2
                            
    isGameOver = true; // 玩家生命值耗尽，游戏结束
                        

                            
3
                            
    showGameOverScreen(); // 显示游戏结束画面
                        

                            
4
                            
}
                        

                            
5
                            

                        

                            
6
                            
if (keyPressed == "Space") {
                        

                            
7
                            
    player.jump(); // 按下空格键，玩家跳跃
                        

                            
8
                            
}
                        

                            
9
                            

                        

                            
10
                            
if (collisionDetected(player, enemy)) {
                        

                            
11
                            
    playerHealth -= enemyDamage; // 检测到碰撞，玩家受到伤害
                        

                            
12
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
switch (expression) {
                        

                            
2
                            
    case value1:
                        

                            
3
                            
        // 当 expression 的值等于 value1 时执行的代码块
                        

                            
4
                            
        break; // 必须使用 break 跳出 switch 语句，否则会继续执行后续 case 分支的代码
                        

                            
5
                            
    case value2:
                        

                            
6
                            
        // 当 expression 的值等于 value2 时执行的代码块
                        

                            
7
                            
        break;
                        

                            
8
                            
    // ... 更多 case 分支
                        

                            
9
                            
    default:
                        

                            
10
                            
        // 当 expression 的值与所有 case 分支的值都不匹配时执行的代码块 (可选)
                        

                            
11
                            
        break;
                        

                            
12
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
switch (gameState) {
                        

                            
2
                            
    case GameState::Menu:
                        

                            
3
                            
        showMainMenu(); // 显示主菜单
                        

                            
4
                            
        break;
                        

                            
5
                            
    case GameState::Playing:
                        

                            
6
                            
        updateGameLogic(); // 更新游戏逻辑
                        

                            
7
                            
        renderGameScene(); // 渲染游戏场景
                        

                            
8
                            
        break;
                        

                            
9
                            
    case GameState::Paused:
                        

                            
10
                            
        showPauseMenu(); // 显示暂停菜单
                        

                            
11
                            
        break;
                        

                            
12
                            
    case GameState::GameOver:
                        

                            
13
                            
        showGameOverScreen(); // 显示游戏结束画面
                        

                            
14
                            
        break;
                        

                            
15
                            
    default:
                        

                            
16
                            
        break;
                        

                            
17
                            
}
                        

                            
18
                            

                        

                            
19
                            
switch (playerInput) {
                        

                            
20
                            
    case Input::MoveLeft:
                        

                            
21
                            
        player.moveLeft(); // 玩家向左移动
                        

                            
22
                            
        break;
                        

                            
23
                            
    case Input::MoveRight:
                        

                            
24
                            
        player.moveRight(); // 玩家向右移动
                        

                            
25
                            
        break;
                        

                            
26
                            
    case Input::Jump:
                        

                            
27
                            
        player.jump(); // 玩家跳跃
                        

                            
28
                            
        break;
                        

                            
29
                            
    default:
                        

                            
30
                            
        break;
                        

                            
31
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
for (initialization; condition; iteration) {
                        

                            
2
                            
    // 循环体代码，重复执行的代码块
                        

                            
3
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
for (int i = 0; i < enemies.size(); ++i) {
                        

                            
2
                            
    enemies[i].update(); // 遍历所有敌人，更新敌人状态
                        

                            
3
                            
    if (collisionDetected(player, enemies[i])) {
                        

                            
4
                            
        playerHealth -= enemies[i].damage; // 检测玩家与每个敌人的碰撞
                        

                            
5
                            
    }
                        

                            
6
                            
}
                        

                            
7
                            

                        

                            
8
                            
for (float angle = 0; angle < 360; angle += 10) {
                        

                            
9
                            
    createParticle(player.x, player.y, angle); // 创建环绕玩家的粒子效果
                        

                            
10
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
while (condition) {
                        

                            
2
                            
    // 循环体代码，当 condition 为真 (true) 时重复执行
                        

                            
3
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
while (!isGameOver) {
                        

                            
2
                            
    processInput(); // 处理玩家输入
                        

                            
3
                            
    updateGameLogic(); // 更新游戏逻辑
                        

                            
4
                            
    renderGameScene(); // 渲染游戏场景
                        

                            
5
                            
} // 游戏主循环，直到游戏结束
                        

                            
6
                            

                        

                            
7
                            
while (resourceLoadingProgress < 1.0f) {
                        

                            
8
                            
    resourceLoadingProgress = loadNextResource(); // 加载资源，直到所有资源加载完成
                        

                            
9
                            
    updateLoadingScreen(resourceLoadingProgress); // 更新加载画面
                        

                            
10
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
do {
                        

                            
2
                            
    // 循环体代码，至少执行一次，然后根据 condition 判断是否继续循环
                        

                            
3
                            
} while (condition);
                        
                                
                            

                                
                                    

                            
1
                            
do {
                        

                            
2
                            
    playerGuess = getPlayerGuess(); // 获取玩家猜测的数字
                        

                            
3
                            
    attempts++; // 尝试次数加 1
                        

                            
4
                            
    displayHint(playerGuess, secretNumber); // 显示提示信息
                        

                            
5
                            
} while (playerGuess != secretNumber && attempts < maxAttempts); // 数字猜谜游戏，直到猜对或超过最大尝试次数
                        
                                
                            

                                
                                    

                            
1
                            
返回类型 函数名(参数列表) {
                        

                            
2
                            
    // 函数体代码
                        

                            
3
                            
    // ...
                        

                            
4
                            
    return 返回值; // 可选，如果函数有返回类型
                        

                            
5
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// 计算两个整数的和，并返回结果
                        

                            
2
                            
int add(int a, int b) {
                        

                            
3
                            
    int sum = a + b;
                        

                            
4
                            
    return sum; // 返回计算结果
                        

                            
5
                            
}
                        

                            
6
                            

                        

                            
7
                            
// 判断一个数是否为偶数，返回布尔值
                        

                            
8
                            
bool isEven(int number) {
                        

                            
9
                            
    if (number % 2 == 0) {
                        

                            
10
                            
        return true; // 是偶数，返回 true
                        

                            
11
                            
    } else {
                        

                            
12
                            
        return false; // 不是偶数，返回 false
                        

                            
13
                            
    }
                        

                            
14
                            
}
                        

                            
15
                            

                        

                            
16
                            
// 在屏幕上打印游戏欢迎信息 (无返回值)
                        

                            
17
                            
void printWelcomeMessage() {
                        

                            
18
                            
    std::cout << "************************" << std::endl;
                        

                            
19
                            
    std::cout << "*  Welcome to My Game! *" << std::endl;
                        

                            
20
                            
    std::cout << "************************" << std::endl;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
函数名(实际参数列表);
                        
                                
                            

                                
                                    

                            
1
                            
int result = add(5, 3); // 调用 add 函数，传递实际参数 5 和 3，返回值存储在 result 变量中
                        

                            
2
                            
std::cout << "5 + 3 = " << result << std::endl; // 输出 5 + 3 = 8
                        

                            
3
                            

                        

                            
4
                            
bool even = isEven(10); // 调用 isEven 函数，传递实际参数 10，返回值存储在 even 变量中
                        

                            
5
                            
if (even) {
                        

                            
6
                            
    std::cout << "10 is an even number." << std::endl; // 输出 10 is an even number.
                        

                            
7
                            
}
                        

                            
8
                            

                        

                            
9
                            
printWelcomeMessage(); // 调用 printWelcomeMessage 函数，无实际参数和返回值
                        
                                
                            

                                
                                    

                            
1
                            
void modifyValue(int value) { // 值传递
                        

                            
2
                            
    value = 100; // 修改的是形式参数 value 的副本，不会影响外部变量
                        

                            
3
                            
    std::cout << "Inside function, value = " << value << std::endl; // 输出 Inside function, value = 100
                        

                            
4
                            
}
                        

                            
5
                            

                        

                            
6
                            
int num = 5;
                        

                            
7
                            
modifyValue(num);
                        

                            
8
                            
std::cout << "Outside function, num = " << num << std::endl; // 输出 Outside function, num = 5 (num 的值未被修改)
                        
                                
                            

                                
                                    

                            
1
                            
void modifyValueByReference(int& value) { // 引用传递，使用 & 符号声明引用参数
                        

                            
2
                            
    value = 100; // 修改的是形式参数 value 引用的实际变量 num
                        

                            
3
                            
    std::cout << "Inside function, value = " << value << std::endl; // 输出 Inside function, value = 100
                        

                            
4
                            
}
                        

                            
5
                            

                        

                            
6
                            
int num = 5;
                        

                            
7
                            
modifyValueByReference(num);
                        

                            
8
                            
std::cout << "Outside function, num = " << num << std::endl; // 输出 Outside function, num = 100 (num 的值被修改)
                        
                                
                            

                                
                                    

                            
1
                            
void printValue(const int& value) { // 常量引用传递，使用 const & 符号声明常量引用参数
                        

                            
2
                            
    std::cout << "Value is: " << value << std::endl; // 可以读取 value 的值，但不能修改
                        

                            
3
                            
    // value = 200; // 编译错误，不能修改常量引用参数
                        

                            
4
                            
}
                        

                            
5
                            

                        

                            
6
                            
int num = 50;
                        

                            
7
                            
printValue(num); // 输出 Value is: 50
                        
                                
                            

                                
                                    

                            
1
                            
// 输入处理模块
                        

                            
2
                            
namespace Input {
                        

                            
3
                            
    InputEvent processInput(); // 处理输入，返回输入事件
                        

                            
4
                            
}
                        

                            
5
                            

                        

                            
6
                            
// 游戏逻辑模块
                        

                            
7
                            
namespace GameLogic {
                        

                            
8
                            
    void updateGame(float deltaTime); // 更新游戏逻辑
                        

                            
9
                            
    void handleCollision(GameObject* object1, GameObject* object2); // 处理碰撞
                        

                            
10
                            
}
                        

                            
11
                            

                        

                            
12
                            
// 渲染模块
                        

                            
13
                            
namespace Renderer {
                        

                            
14
                            
    void renderScene(const Scene& scene); // 渲染游戏场景
                        

                            
15
                            
    void renderUI(const UI& ui); // 渲染用户界面
                        

                            
16
                            
}
                        

                            
17
                            

                        

                            
18
                            
// 主游戏循环
                        

                            
19
                            
int main() {
                        

                            
20
                            
    initializeGame(); // 初始化游戏
                        

                            
21
                            
    while (!isGameOver()) {
                        

                            
22
                            
        InputEvent inputEvent = Input::processInput(); // 处理输入
                        

                            
23
                            
        GameLogic::updateGame(deltaTime); // 更新游戏逻辑
                        

                            
24
                            
        Renderer::renderScene(gameScene); // 渲染游戏场景
                        

                            
25
                            
        Renderer::renderUI(gameUI); // 渲染用户界面
                        

                            
26
                            
        // ...
                        

                            
27
                            
    }
                        

                            
28
                            
    shutdownGame(); // 关闭游戏
                        

                            
29
                            
    return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
class 类名 { // 使用 class 关键字定义类
                        

                            
2
                            
private: // 私有成员 (只能在类内部访问)
                        

                            
3
                            
    // 私有成员变量
                        

                            
4
                            
    // 私有成员函数
                        

                            
5
                            

                        

                            
6
                            
protected: // 保护成员 (可以在类内部和派生类中访问)
                        

                            
7
                            
    // 保护成员变量
                        

                            
8
                            
    // 保护成员函数
                        

                            
9
                            

                        

                            
10
                            
public:  // 公有成员 (可以在任何地方访问)
                        

                            
11
                            
    // 公有成员变量
                        

                            
12
                            
    // 公有成员函数
                        

                            
13
                            
}; // 类定义结束时需要加分号
                        
                                
                            

                                
                                    

                            
1
                            
#include <string>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
class GameObject {
                        

                            
5
                            
private: // 私有成员
                        

                            
6
                            
    float x;       // x 坐标
                        

                            
7
                            
    float y;       // y 坐标
                        

                            
8
                            
    float speed;   // 移动速度
                        

                            
9
                            
    int health;    // 生命值
                        

                            
10
                            
    std::string name; // 名称
                        

                            
11
                            

                        

                            
12
                            
protected: // 保护成员 (此处示例中暂无)
                        

                            
13
                            

                        

                            
14
                            
public:  // 公有成员
                        

                            
15
                            
    // 构造函数 (Constructor)，用于初始化对象
                        

                            
16
                            
    GameObject(float startX, float startY, float startSpeed, int startHealth, const std::string& startName)
                        

                            
17
                            
        : x(startX), y(startY), speed(startSpeed), health(startHealth), name(startName) {
                        

                            
18
                            
        std::cout << "GameObject '" << name << "' created at (" << x << ", " << y << ")" << std::endl;
                        

                            
19
                            
    }
                        

                            
20
                            

                        

                            
21
                            
    // 析构函数 (Destructor)，用于在对象销毁时执行清理操作 (此处示例中暂无特殊清理操作)
                        

                            
22
                            
    ~GameObject() {
                        

                            
23
                            
        std::cout << "GameObject '" << name << "' destroyed." << std::endl;
                        

                            
24
                            
    }
                        

                            
25
                            

                        

                            
26
                            
    // 公有成员函数 (方法)
                        

                            
27
                            
    void move(float dx, float dy) {
                        

                            
28
                            
        x += dx * speed;
                        

                            
29
                            
        y += dy * speed;
                        

                            
30
                            
        std::cout << "GameObject '" << name << "' moved to (" << x << ", " << y << ")" << std::endl;
                        

                            
31
                            
    }
                        

                            
32
                            

                        

                            
33
                            
    void takeDamage(int damage) {
                        

                            
34
                            
        health -= damage;
                        

                            
35
                            
        if (health < 0) {
                        

                            
36
                            
            health = 0; // 生命值不能为负数
                        

                            
37
                            
        }
                        

                            
38
                            
        std::cout << "GameObject '" << name << "' took " << damage << " damage. Health: " << health << std::endl;
                        

                            
39
                            
    }
                        

                            
40
                            

                        

                            
41
                            
    void render() const { // const 成员函数，表示该函数不会修改对象的状态
                        

                            
42
                            
        std::cout << "Rendering GameObject '" << name << "' at (" << x << ", " << y << ")" << std::endl;
                        

                            
43
                            
        // 实际渲染逻辑 (例如使用图形 API 绘制精灵或模型)
                        

                            
44
                            
    }
                        

                            
45
                            

                        

                            
46
                            
    // Getter 方法 (访问器)，用于获取私有成员变量的值 (只读访问)
                        

                            
47
                            
    float getX() const { return x; }
                        

                            
48
                            
    float getY() const { return y; }
                        

                            
49
                            
    float getSpeed() const { return speed; }
                        

                            
50
                            
    int getHealth() const { return health; }
                        

                            
51
                            
    const std::string& getName() const { return name; }
                        

                            
52
                            

                        

                            
53
                            
    // Setter 方法 (修改器)，用于设置私有成员变量的值 (受控修改)
                        

                            
54
                            
    void setSpeed(float newSpeed) {
                        

                            
55
                            
        if (newSpeed >= 0) { // 可以添加参数验证逻辑
                        

                            
56
                            
            speed = newSpeed;
                        

                            
57
                            
            std::cout << "GameObject '" << name << "' speed set to " << speed << std::endl;
                        

                            
58
                            
        } else {
                        

                            
59
                            
            std::cerr << "Error: Speed cannot be negative." << std::endl;
                        

                            
60
                            
        }
                        

                            
61
                            
    }
                        

                            
62
                            
    void setHealth(int newHealth) {
                        

                            
63
                            
        health = newHealth;
                        

                            
64
                            
    }
                        

                            
65
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
类名 对象名(构造函数参数列表); // 使用构造函数创建对象
                        
                                
                            

                                
                                    

                            
1
                            
int main() {
                        

                            
2
                            
    // 创建 GameObject 类的对象 (实例)
                        

                            
3
                            
    GameObject player(100.0f, 200.0f, 7.0f, 100, "Player"); // 调用 GameObject 类的构造函数创建 player 对象
                        

                            
4
                            
    GameObject enemy(300.0f, 200.0f, 5.0f, 50, "Enemy");    // 调用 GameObject 类的构造函数创建 enemy 对象
                        

                            
5
                            

                        

                            
6
                            
    // 调用对象的成员函数 (方法)
                        

                            
7
                            
    player.move(1.0f, 0.0f); // 调用 player 对象的 move 方法，向右移动
                        

                            
8
                            
    enemy.move(-1.0f, 0.0f); // 调用 enemy 对象的 move 方法，向左移动
                        

                            
9
                            

                        

                            
10
                            
    player.takeDamage(10);   // 调用 player 对象的 takeDamage 方法，受到 10 点伤害
                        

                            
11
                            
    enemy.takeDamage(5);     // 调用 enemy 对象的 takeDamage 方法，受到 5 点伤害
                        

                            
12
                            

                        

                            
13
                            
    player.render();         // 调用 player 对象的 render 方法，渲染玩家对象
                        

                            
14
                            
    enemy.render();          // 调用 enemy 对象的 render 方法，渲染敌人对象
                        

                            
15
                            

                        

                            
16
                            
    std::cout << "Player's health: " << player.getHealth() << std::endl; // 使用 getter 方法获取 player 对象的生命值
                        

                            
17
                            
    std::cout << "Enemy's health: " << enemy.getHealth() << std::endl;   // 使用 getter 方法获取 enemy 对象的生命值
                        

                            
18
                            

                        

                            
19
                            
    player.setSpeed(10.0f); // 使用 setter 方法修改 player 对象的移动速度
                        

                            
20
                            

                        

                            
21
                            
    return 0;
                        

                            
22
                            
} // 程序结束时，player 和 enemy 对象会被销毁，析构函数会被调用
                        
                                
                            

                                
                                    

                            
1
                            
class 派生类名 : 继承方式 基类名 {
                        

                            
2
                            
    // 派生类特有的成员变量和成员函数
                        

                            
3
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class 抽象类名 {
                        

                            
2
                            
public:
                        

                            
3
                            
    virtual 返回类型 纯虚函数名(参数列表) = 0; // 纯虚函数声明，注意 = 0
                        

                            
4
                            
    // ... 其他成员 (可以包含普通成员变量和成员函数，以及非纯虚函数)
                        

                            
5
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class IMyInterface { // 使用抽象类模拟接口，类名通常以 I 开头
                        

                            
2
                            
public:
                        

                            
3
                            
    virtual void method1() = 0; // 纯虚函数
                        

                            
4
                            
    virtual int method2(int arg) = 0; // 纯虚函数
                        

                            
5
                            
    virtual ~IMyInterface() = default; // 虚析构函数 (接口通常需要虚析构函数，以便正确析构派生类对象)
                        

                            
6
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
class IProtocol { // 协议类
                        

                            
2
                            
public:
                        

                            
3
                            
    virtual void sendData(const std::string& data) = 0;
                        

                            
4
                            
    virtual std::string receiveData() = 0;
                        

                            
5
                            
    virtual ~IProtocol() = default;
                        

                            
6
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
// 固定时间步示例 (伪代码)
                        

                            
2
                            
double fixedTimeStep = 1.0 / 60.0; // 目标 60 FPS
                        

                            
3
                            
double accumulator = 0.0;
                        

                            
4
                            
double currentTime = getCurrentTime();
                        

                            
5
                            

                        

                            
6
                            
while (gameIsRunning) {
                        

                            
7
                            
    double newTime = getCurrentTime();
                        

                            
8
                            
    double frameTime = newTime - currentTime;
                        

                            
9
                            
    currentTime = newTime;
                        

                            
10
                            

                        

                            
11
                            
    accumulator += frameTime;
                        

                            
12
                            

                        

                            
13
                            
    while (accumulator >= fixedTimeStep) {
                        

                            
14
                            
        processInput();      // 处理输入
                        

                            
15
                            
        updateGame(fixedTimeStep); // 使用固定时间步更新游戏状态
                        

                            
16
                            
        accumulator -= fixedTimeStep;
                        

                            
17
                            
    }
                        

                            
18
                            

                        

                            
19
                            
    renderGame();          // 渲染游戏画面
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// 可变时间步示例 (伪代码)
                        

                            
2
                            
double currentTime = getCurrentTime();
                        

                            
3
                            

                        

                            
4
                            
while (gameIsRunning) {
                        

                            
5
                            
    double newTime = getCurrentTime();
                        

                            
6
                            
    double frameTime = newTime - currentTime; // 计算帧时间
                        

                            
7
                            
    currentTime = newTime;
                        

                            
8
                            

                        

                            
9
                            
    processInput();      // 处理输入
                        

                            
10
                            
    updateGame(frameTime); // 使用可变时间步更新游戏状态
                        

                            
11
                            
    renderGame();          // 渲染游戏画面
                        

                            
12
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// 使用 SFML 渲染精灵示例
                        

                            
2
                            
#include <SFML/Graphics.hpp>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
    sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Sprites");
                        

                            
6
                            

                        

                            
7
                            
    // 加载纹理
                        

                            
8
                            
    sf::Texture texture;
                        

                            
9
                            
    if (!texture.loadFromFile("player.png")) {
                        

                            
10
                            
        return -1;
                        

                            
11
                            
    }
                        

                            
12
                            

                        

                            
13
                            
    // 创建精灵
                        

                            
14
                            
    sf::Sprite sprite;
                        

                            
15
                            
    sprite.setTexture(texture);
                        

                            
16
                            
    sprite.setPosition(100, 100);
                        

                            
17
                            

                        

                            
18
                            
    while (window.isOpen()) {
                        

                            
19
                            
        sf::Event event;
                        

                            
20
                            
        while (window.pollEvent(event)) {
                        

                            
21
                            
            if (event.type == sf::Event::Closed) {
                        

                            
22
                            
                window.close();
                        

                            
23
                            
            }
                        

                            
24
                            
        }
                        

                            
25
                            

                        

                            
26
                            
        window.clear();
                        

                            
27
                            
        window.draw(sprite); // 绘制精灵
                        

                            
28
                            
        window.display();
                        

                            
29
                            
    }
                        

                            
30
                            

                        

                            
31
                            
    return 0;
                        

                            
32
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// SDL 渲染示例 (伪代码)
                        

                            
2
                            
SDL_Window* window = SDL_CreateWindow(...);
                        

                            
3
                            
SDL_Renderer* renderer = SDL_CreateRenderer(window, ...);
                        

                            
4
                            
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
                        

                            
5
                            
SDL_Rect destRect = { 100, 100, textureWidth, textureHeight };
                        

                            
6
                            

                        

                            
7
                            
SDL_RenderClear(renderer);
                        

                            
8
                            
SDL_RenderCopy(renderer, texture, NULL, &destRect); // 渲染纹理到指定区域
                        

                            
9
                            
SDL_RenderPresent(renderer);
                        
                                
                            

                                
                                    

                            
1
                            
// SFML 渲染示例 (伪代码)
                        

                            
2
                            
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Render");
                        

                            
3
                            
sf::Texture texture;
                        

                            
4
                            
texture.loadFromFile("sprite.png");
                        

                            
5
                            
sf::Sprite sprite(texture);
                        

                            
6
                            
sprite.setPosition(100, 100);
                        

                            
7
                            

                        

                            
8
                            
window.clear();
                        

                            
9
                            
window.draw(sprite); // 绘制精灵
                        

                            
10
                            
window.display();
                        
                                
                            

                                
                                    

                            
1
                            
// SDL 键盘事件处理示例
                        

                            
2
                            
#include <SDL.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    SDL_Init(SDL_INIT_VIDEO);
                        

                            
7
                            
    SDL_Window* window = SDL_CreateWindow("SDL Keyboard Input", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, 0);
                        

                            
8
                            
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
                        

                            
9
                            

                        

                            
10
                            
    bool quit = false;
                        

                            
11
                            
    SDL_Event event;
                        

                            
12
                            

                        

                            
13
                            
    while (!quit) {
                        

                            
14
                            
        while (SDL_PollEvent(&event)) {
                        

                            
15
                            
            if (event.type == SDL_QUIT) {
                        

                            
16
                            
                quit = true;
                        

                            
17
                            
            } else if (event.type == SDL_KEYDOWN) { // 按键按下事件
                        

                            
18
                            
                switch (event.key.keysym.sym) { // 获取按键代码
                        

                            
19
                            
                    case SDLK_UP:
                        

                            
20
                            
                        std::cout << "Up arrow key pressed" << std::endl;
                        

                            
21
                            
                        break;
                        

                            
22
                            
                    case SDLK_DOWN:
                        

                            
23
                            
                        std::cout << "Down arrow key pressed" << std::endl;
                        

                            
24
                            
                        break;
                        

                            
25
                            
                    case SDLK_LEFT:
                        

                            
26
                            
                        std::cout << "Left arrow key pressed" << std::endl;
                        

                            
27
                            
                        break;
                        

                            
28
                            
                    case SDLK_RIGHT:
                        

                            
29
                            
                        std::cout << "Right arrow key pressed" << std::endl;
                        

                            
30
                            
                        break;
                        

                            
31
                            
                    case SDLK_ESCAPE:
                        

                            
32
                            
                        quit = true; // 按下 ESC 键退出
                        

                            
33
                            
                        break;
                        

                            
34
                            
                    default:
                        

                            
35
                            
                        break;
                        

                            
36
                            
                }
                        

                            
37
                            
            } else if (event.type == SDL_KEYUP) { // 按键释放事件
                        

                            
38
                            
                switch (event.key.keysym.sym) {
                        

                            
39
                            
                    case SDLK_UP:
                        

                            
40
                            
                        std::cout << "Up arrow key released" << std::endl;
                        

                            
41
                            
                        break;
                        

                            
42
                            
                    // ... 其他按键释放事件处理
                        

                            
43
                            
                    default:
                        

                            
44
                            
                        break;
                        

                            
45
                            
                }
                        

                            
46
                            
            }
                        

                            
47
                            
        }
                        

                            
48
                            

                        

                            
49
                            
        SDL_RenderClear(renderer);
                        

                            
50
                            
        // ... 渲染游戏画面
                        

                            
51
                            
        SDL_RenderPresent(renderer);
                        

                            
52
                            
    }
                        

                            
53
                            

                        

                            
54
                            
    SDL_DestroyRenderer(renderer);
                        

                            
55
                            
    SDL_DestroyWindow(window);
                        

                            
56
                            
    SDL_Quit();
                        

                            
57
                            

                        

                            
58
                            
    return 0;
                        

                            
59
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// SFML 鼠标事件处理示例
                        

                            
2
                            
#include <SFML/Graphics.hpp>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    sf::RenderWindow window(sf::VideoMode(800, 600), "SFML Mouse Input");
                        

                            
7
                            

                        

                            
8
                            
    while (window.isOpen()) {
                        

                            
9
                            
        sf::Event event;
                        

                            
10
                            
        while (window.pollEvent(event)) {
                        

                            
11
                            
            if (event.type == sf::Event::Closed) {
                        

                            
12
                            
                window.close();
                        

                            
13
                            
            } else if (event.type == sf::Event::MouseButtonPressed) { // 鼠标按键按下事件
                        

                            
14
                            
                if (event.mouseButton.button == sf::Mouse::Left) { // 左键按下
                        

                            
15
                            
                    sf::Vector2i mousePosition = sf::Mouse::getPosition(window); // 获取鼠标在窗口中的位置
                        

                            
16
                            
                    std::cout << "Left mouse button pressed at (" << mousePosition.x << ", " << mousePosition.y << ")" << std::endl;
                        

                            
17
                            
                    // ... 执行左键点击操作
                        

                            
18
                            
                } else if (event.mouseButton.button == sf::Mouse::Right) { // 右键按下
                        

                            
19
                            
                    std::cout << "Right mouse button pressed" << std::endl;
                        

                            
20
                            
                    // ... 执行右键点击操作
                        

                            
21
                            
                }
                        

                            
22
                            
            } else if (event.type == sf::Event::MouseMoved) { // 鼠标移动事件
                        

                            
23
                            
                sf::Vector2i mousePosition = sf::Mouse::getPosition(window);
                        

                            
24
                            
                // ... 根据鼠标位置更新游戏逻辑 (例如移动光标)
                        

                            
25
                            
            } else if (event.type == sf::Event::MouseWheelScrolled) { // 鼠标滚轮事件
                        

                            
26
                            
                float delta = event.mouseWheelScroll.delta; // 滚轮滚动方向和幅度
                        

                            
27
                            
                // ... 根据滚轮滚动调整游戏逻辑 (例如缩放视角)
                        

                            
28
                            
            }
                        

                            
29
                            
        }
                        

                            
30
                            

                        

                            
31
                            
        window.clear();
                        

                            
32
                            
        // ... 渲染游戏画面
                        

                            
33
                            
        window.display();
                        

                            
34
                            
    }
                        

                            
35
                            

                        

                            
36
                            
    return 0;
                        

                            
37
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// SDL 游戏手柄事件处理示例
                        

                            
2
                            
#include <SDL.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    SDL_Init(SDL_INIT_JOYSTICK);
                        

                            
7
                            
    SDL_Joystick* joystick = NULL;
                        

                            
8
                            

                        

                            
9
                            
    if (SDL_NumJoysticks() > 0) {
                        

                            
10
                            
        joystick = SDL_JoystickOpen(0); // 打开第一个连接的游戏手柄
                        

                            
11
                            
        if (joystick) {
                        

                            
12
                            
            std::cout << "Found joystick: " << SDL_JoystickName(joystick) << std::endl;
                        

                            
13
                            
        } else {
                        

                            
14
                            
            std::cerr << "Could not open joystick! SDL Error: " << SDL_GetError() << std::endl;
                        

                            
15
                            
        }
                        

                            
16
                            
    } else {
                        

                            
17
                            
        std::cout << "No joysticks found." << std::endl;
                        

                            
18
                            
    }
                        

                            
19
                            

                        

                            
20
                            
    SDL_Window* window = SDL_CreateWindow("SDL Gamepad Input", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, 0);
                        

                            
21
                            
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
                        

                            
22
                            

                        

                            
23
                            
    bool quit = false;
                        

                            
24
                            
    SDL_Event event;
                        

                            
25
                            

                        

                            
26
                            
    while (!quit) {
                        

                            
27
                            
        while (SDL_PollEvent(&event)) {
                        

                            
28
                            
            if (event.type == SDL_QUIT) {
                        

                            
29
                            
                quit = true;
                        

                            
30
                            
            } else if (event.type == SDL_JOYBUTTONDOWN) { // 手柄按钮按下事件
                        

                            
31
                            
                if (event.jbutton.which == 0) { // 检查是哪个手柄的事件 (如果只有一个手柄，which 通常为 0)
                        

                            
32
                            
                    int buttonIndex = event.jbutton.button; // 获取按钮索引
                        

                            
33
                            
                    std::cout << "Joystick button " << buttonIndex << " pressed" << std::endl;
                        

                            
34
                            
                    // ... 根据按钮索引执行相应操作
                        

                            
35
                            
                }
                        

                            
36
                            
            } else if (event.type == SDL_JOYAXISMOTION) { // 手柄摇杆移动事件
                        

                            
37
                            
                if (event.jaxis.which == 0) {
                        

                            
38
                            
                    int axisIndex = event.jaxis.axis; // 获取轴索引 (例如 0: 左摇杆 X 轴, 1: 左摇杆 Y 轴)
                        

                            
39
                            
                    float axisValue = event.jaxis.value / 32767.0f; // 轴值范围通常是 -32768 到 32767，归一化到 -1.0 到 1.0
                        

                            
40
                            
                    std::cout << "Joystick axis " << axisIndex << " motion: " << axisValue << std::endl;
                        

                            
41
                            
                    // ... 根据轴值控制角色移动或视角
                        

                            
42
                            
                }
                        

                            
43
                            
            }
                        

                            
44
                            
        }
                        

                            
45
                            

                        

                            
46
                            
        SDL_RenderClear(renderer);
                        

                            
47
                            
        // ... 渲染游戏画面
                        

                            
48
                            
        SDL_RenderPresent(renderer);
                        

                            
49
                            
    }
                        

                            
50
                            

                        

                            
51
                            
    if (joystick) {
                        

                            
52
                            
        SDL_JoystickClose(joystick);
                        

                            
53
                            
    }
                        

                            
54
                            
    SDL_DestroyRenderer(renderer);
                        

                            
55
                            
    SDL_DestroyWindow(window);
                        

                            
56
                            
    SDL_Quit();
                        

                            
57
                            

                        

                            
58
                            
    return 0;
                        

                            
59
                            
}