用C++写一个魂斗罗游戏

写一个完整的魂斗罗游戏需要多个模块，包括游戏引擎、图形界面、音频引擎、游戏逻辑等。在这里，我提供一些思路和方法来实现一个简单的魂斗罗游戏。

1. 游戏引擎

游戏引擎是整个游戏的基础，它需要实现游戏的主循环、状态管理、用户输入处理等功能。你可以使用 SDL 或 Allegro 等游戏引擎库来实现这些功能。

2. 图形界面

魂斗罗是一个二维横版射击游戏，需要实现精灵、地图、背景等图形元素的绘制。你可以使用 SDL 或 Allegro 的绘图库来实现这些功能。

3. 音频引擎

魂斗罗需要实现背景音乐、音效等声音效果。你可以使用 SDL_mixer 或 Allegro 的音频库来实现这些功能。

4. 游戏逻辑

魂斗罗的游戏逻辑包括角色控制、敌人 AI、碰撞检测、道具系统等。你可以使用 C 语言实现这些功能。

下面是一个简单的魂斗罗游戏的代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include <SDL2/SDL.h>

#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define SPRITE_SIZE 32
#define MAX_ENEMIES 10

typedef struct {
    int x, y;
    int speed;
    bool alive;
    SDL_Texture* texture;
} Enemy;

typedef struct {
    int x, y;
    SDL_Texture* texture;
} Player;

SDL_Window* window;
SDL_Renderer* renderer;
SDL_Texture* bg_texture;
SDL_Texture* player_texture;
SDL_Texture* enemy_texture;
SDL_Texture* bullet_texture;
Player player;
Enemy enemies[MAX_ENEMIES];
int score = 0;

void init() {
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
    window = SDL_CreateWindow("Contra", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    SDL_RenderPresent(renderer);
    SDL_Surface* bg_surface = SDL_LoadBMP("bg.bmp");
    bg_texture = SDL_CreateTextureFromSurface(renderer, bg_surface);
    SDL_FreeSurface(bg_surface);
    SDL_Surface* player_surface = SDL_LoadBMP("player.bmp");
    player_texture = SDL_CreateTextureFromSurface(renderer, player_surface);
    SDL_FreeSurface(player_surface);
    SDL_Surface* enemy_surface = SDL_LoadBMP("enemy.bmp");
    enemy_texture = SDL_CreateTextureFromSurface(renderer, enemy_surface);
    SDL_FreeSurface(enemy_surface);
    SDL_Surface* bullet_surface = SDL_LoadBMP("bullet.bmp");
    bullet_texture = SDL_CreateTextureFromSurface(renderer, bullet_surface);
    SDL_FreeSurface(bullet_surface);
    player.x = SCREEN_WIDTH / 2 - SPRITE_SIZE / 2;
    player.y = SCREEN_HEIGHT - SPRITE_SIZE;
    for (int i = 0; i < MAX_ENEMIES; i++) {
        enemies[i].alive = false;
        enemies[i].texture = enemy_texture;
    }
}

void quit() {
    SDL_DestroyTexture(bg_texture);
    SDL_DestroyTexture(player_texture);
    SDL_DestroyTexture(enemy_texture);
    SDL_DestroyTexture(bullet_texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
}

void add_enemy() {
    for (int i = 0; i < MAX_ENEMIES; i++) {
        if (!enemies[i].alive) {
            enemies[i].x = rand() % (SCREEN_WIDTH - SPRITE_SIZE);
            enemies[i].y = -SPRITE_SIZE;
            enemies[i].speed = rand() % 3 + 1;
            enemies[i].alive = true;
            break;
        }
    }
}

void update_enemies() {
    for (int i = 0; i < MAX_ENEMIES; i++) {
        if (enemies[i].alive) {
            enemies[i].y += enemies[i].speed;
            if (enemies[i].y >= SCREEN_HEIGHT) {
                enemies[i].alive = false;
            }
        }
    }
}

void draw_enemies() {
    for (int i = 0; i < MAX_ENEMIES; i++) {
        if (enemies[i].alive) {
            SDL_Rect rect = {enemies[i].x, enemies[i].y, SPRITE_SIZE, SPRITE_SIZE};
            SDL_RenderCopy(renderer, enemies[i].texture, NULL, &rect);
        }
    }
}

void draw_player() {
    SDL_Rect rect = {player.x, player.y, SPRITE_SIZE, SPRITE_SIZE};
    SDL_RenderCopy(renderer, player_texture, NULL, &rect);
}

void move_player(int dx, int dy) {
    player.x += dx;
    player.y += dy;
    if (player.x < 0) {
        player.x = 0;
    }
    if (player.x > SCREEN_WIDTH - SPRITE_SIZE) {
        player.x = SCREEN_WIDTH - SPRITE_SIZE;
    }
    if (player.y < 0) {
        player.y = 0;
    }
    if (player.y > SCREEN_HEIGHT - SPRITE_SIZE) {
        player.y = SCREEN_HEIGHT - SPRITE_SIZE;
    }
}

void fire() {
    SDL_Rect rect = {player.x + SPRITE_SIZE / 2, player.y, 4, 8};
    SDL_RenderCopy(renderer, bullet_texture, NULL, &rect);
    for (int i = 0; i < MAX_ENEMIES; i++) {
        if (enemies[i].alive) {
            if (enemies[i].x < player.x + SPRITE_SIZE / 2 && enemies[i].x + SPRITE_SIZE > player.x + SPRITE_SIZE / 2
                && enemies[i].y < player.y && enemies[i].y + SPRITE_SIZE > player.y) {
                enemies[i].alive = false;
                score += 10;
            }
        }
    }
}

int main(int argc, char* argv[]) {
    srand(time(NULL));
    init();
    bool running = true;
    while (running) {
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            switch (event.type) {
                case SDL_QUIT:
                    running = false;
                    break;
                case SDL_KEYDOWN:
                    switch (event.key.keysym.sym) {
                        case SDLK_LEFT:
                            move_player(-SPRITE_SIZE / 4, 0);
                            break;
                        case SDLK_RIGHT:
                            move_player(SPRITE_SIZE / 4, 0);
                            break;
                        case SDLK_UP:
                            move_player(0, -SPRITE_SIZE / 4);
                            break;
                        case SDLK_DOWN:
                            move_player(0, SPRITE_SIZE / 4);
                            break;
                        case SDLK_SPACE:
                            fire();
                            break;
                    }
                    break;
            }
        }
        SDL_RenderCopy(renderer, bg_texture, NULL, NULL);
        add_enemy();
        update_enemies();
        draw_enemies();
        draw_player();
        SDL_RenderPresent(renderer);
        SDL_Delay(10);
    }
    quit();
    return 0;
}

这个代码示例实现了一个简单的魂斗罗游戏，包括主角移动、射击、敌人生成、敌人移动等功能。你可以根据这个示例代码来实现你自己的魂斗罗游戏。