C++编写一个跑酷游戏

跑酷游戏的实现可以分为以下几个步骤：

1. 创建窗口和游戏场景
使用 C++ 的图形库（如 SDL 或 SFML）创建游戏窗口，然后在窗口中创建游戏场景。游戏场景可以包括游戏背景、游戏角色和障碍物等。

2. 处理用户输入
使用 C++ 的输入库（如 SDL 或 SFML）来处理用户输入，包括键盘和鼠标事件。根据用户的输入来控制游戏角色的移动和跳跃等操作。

3. 实现游戏逻辑
实现游戏的逻辑，包括游戏角色的移动、跳跃和碰撞检测等。游戏角色在跑酷游戏中通常会自动向前移动，玩家需要控制游戏角色跳过障碍物和收集游戏道具等。

4. 添加游戏音效和音乐
使用 C++ 的音频库（如 SDL_mixer 或 SFML）来添加游戏音效和音乐，增强游戏的体验。

下面是一个使用 SDL2 编写的简单跑酷游戏示例代码：

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <iostream>

const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

const int PLAYER_WIDTH = 64;
const int PLAYER_HEIGHT = 64;
const int PLAYER_SPEED = 5;

const int OBSTACLE_WIDTH = 32;
const int OBSTACLE_HEIGHT = 32;
const int OBSTACLE_SPEED = 3;

const int MAX_OBSTACLES = 5;

SDL_Window* gWindow = nullptr;
SDL_Renderer* gRenderer = nullptr;

SDL_Texture* gPlayerTexture = nullptr;
SDL_Rect gPlayerRect = { 0, SCREEN_HEIGHT / 2 - PLAYER_HEIGHT / 2, PLAYER_WIDTH, PLAYER_HEIGHT };

SDL_Texture* gObstacleTexture = nullptr;
SDL_Rect gObstacleRect[MAX_OBSTACLES];

bool init()
{
    bool success = true;

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
    {
        std::cerr << "SDL initialization failed: " << SDL_GetError() << std::endl;
        success = false;
    }
    else
    {
        gWindow = SDL_CreateWindow("Running Game", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
        if (gWindow == nullptr)
        {
            std::cerr << "Window creation failed: " << SDL_GetError() << std::endl;
            success = false;
        }
        else
        {
            gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);
            if (gRenderer == nullptr)
            {
                std::cerr << "Renderer creation failed: " << SDL_GetError() << std::endl;
                success = false;
            }
            else
            {
                SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);

                int imgFlags = IMG_INIT_PNG;
                if (!(IMG_Init(imgFlags) & imgFlags))
                {
                    std::cerr << "SDL_image initialization failed: " << IMG_GetError() << std::endl;
                    success = false;
                }
            }
        }
    }

    return success;
}

bool loadMedia()
{
    bool success = true;

    SDL_Surface* playerSurface = IMG_Load("player.png");
    if (playerSurface == nullptr)
    {
        std::cerr << "Player image loading failed: " << IMG_GetError() << std::endl;
        success = false;
    }
    else
    {
        gPlayerTexture = SDL_CreateTextureFromSurface(gRenderer, playerSurface);
        if (gPlayerTexture == nullptr)
        {
            std::cerr << "Player texture creation failed: " << SDL_GetError() << std::endl;
            success = false;
        }

        SDL_FreeSurface(playerSurface);
    }

    SDL_Surface* obstacleSurface = IMG_Load("obstacle.png");
    if (obstacleSurface == nullptr)
    {
        std::cerr << "Obstacle image loading failed: " << IMG_GetError() << std::endl;
        success = false;
    }
    else
    {
        gObstacleTexture = SDL_CreateTextureFromSurface(gRenderer, obstacleSurface);
        if (gObstacleTexture == nullptr)
        {
            std::cerr << "Obstacle texture creation failed: " << SDL_GetError() << std::endl;
            success = false;
        }

        SDL_FreeSurface(obstacleSurface);
    }

    return success;
}

void close()
{
    SDL_DestroyTexture(gPlayerTexture);
    SDL_DestroyTexture(gObstacleTexture);
    SDL_DestroyRenderer(gRenderer);
    SDL_DestroyWindow(gWindow);

    gPlayerTexture = nullptr;
    gObstacleTexture = nullptr;
    gRenderer = nullptr;
    gWindow = nullptr;

    IMG_Quit();
    SDL_Quit();
}

int main(int argc, char* argv[])
{
    if (!init())
    {
        std::cerr << "Initialization failed!" << std::endl;
        return -1;
    }

    if (!loadMedia())
    {
        std::cerr << "Media loading failed!" << std::endl;
        return -1;
    }

    bool quit = false;

    int obstacleX[MAX_OBSTACLES] = { SCREEN_WIDTH };
    int obstacleY[MAX_OBSTACLES] = { SCREEN_HEIGHT / 2 - OBSTACLE_HEIGHT / 2 };

    while (!quit)
    {
        SDL_Event e;
        while (SDL_PollEvent(&e) != 0)
        {
            if (e.type == SDL_QUIT)
            {
                quit = true;
            }
        }

        const Uint8* keystate = SDL_GetKeyboardState(nullptr);
        if (keystate[SDL_SCANCODE_UP])
        {
            gPlayerRect.y -= PLAYER_SPEED;
        }
        else if (keystate[SDL_SCANCODE_DOWN])
        {
            gPlayerRect.y += PLAYER_SPEED;
        }

        for (int i = 0; i < MAX_OBSTACLES; ++i)
        {
            obstacleX[i] -= OBSTACLE_SPEED;
            if (obstacleX[i] < -OBSTACLE_WIDTH)
            {
                obstacleX[i] = SCREEN_WIDTH;
            }

            SDL_Rect obstacleRect = { obstacleX[i], obstacleY[i], OBSTACLE_WIDTH, OBSTACLE_HEIGHT };
            if (SDL_HasIntersection(&gPlayerRect, &obstacleRect))
            {
                std::cout << "Game over!" << std::endl;
                quit = true;
            }
        }

        SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
        SDL_RenderClear(gRenderer);

        SDL_RenderCopy(gRenderer, gPlayerTexture, nullptr, &gPlayerRect);

        for (int i = 0; i < MAX_OBSTACLES; ++i)
        {
            SDL_Rect obstacleRect = { obstacleX[i], obstacleY[i], OBSTACLE_WIDTH, OBSTACLE_HEIGHT };
            SDL_RenderCopy(gRenderer, gObstacleTexture, nullptr, &obstacleRect);
        }

        SDL_RenderPresent(gRenderer);
    }

    close();

    return 0;
}

在代码中，我们使用 SDL2 图形库创建了一个名为 "Running Game" 的游戏窗口，并在窗口中渲染了游戏角色和障碍物。玩家可以使用键盘上下键来控制游戏角色的上下移动，障碍物会从右侧向左侧移动，当游戏角色与障碍物发生碰撞时游戏结束。