C++实现简单射击小游戏

C++实现简单射击小游戏攻略

1. 游戏规则

本游戏的规则如下：

• 游戏分为若干轮，每轮有若干个目标，目标会随机移动。
• 玩家需要使用键盘上的箭头键来移动瞄准器，使用空格键来射击。
• 每轮结束后，显示本轮的得分，并提示是否继续游戏。

2. 实现步骤

2.1 游戏框架搭建

游戏框架主要包括三个类：游戏引擎类（GameEngine）、目标类（Target）和玩家类（Player）。其中，游戏引擎类是游戏的核心类，用于控制游戏的进程；目标类用于表示游戏中出现的目标；玩家类用于表示玩家。

class GameEngine {
public:
  GameEngine();  // 构造函数
  void run();    // 游戏运行函数
private:
  int round_;    // 当前游戏轮数
  bool is_over_; // 游戏是否结束
  Player player_; // 玩家
  vector<Target> targets_; // 目标
};

class Target {
public:
  Target();  // 构造函数
  void move(); // 目标移动函数
  bool is_hit(int x, int y); // 判断是否命中目标函数
private:
  int x_, y_; // 目标中心坐标
  int radius_; // 目标半径
  int speed_; // 目标移动速度
};

class Player {
public:
  Player(); // 构造函数
  void move(int dx, int dy); // 玩家移动函数
  void fire(); // 射击函数
private:
  int x_, y_;   // 瞄准器中心坐标
  int score_;   // 玩家得分
  int bullets_; // 玩家剩余子弹数
};

2.2 目标类实现

目标类主要包括目标的位置、半径和移动速度，以及目标的运动和命中判定函数。

Target::Target() {
  x_ = rand() % kScreenWidth;
  y_ = rand() % kScreenHeight;
  radius_ = 20;
  speed_ = 10;
}

void Target::move() {
  int dx = speed_ * ((rand() % 3) - 1);
  int dy = speed_ * ((rand() % 3) - 1);
  x_ += dx;
  y_ += dy;
  if (x_ < radius_) x_ = radius_;
  if (x_ > kScreenWidth - radius_) x_ = kScreenWidth - radius_;
  if (y_ < radius_) y_ = radius_;
  if (y_ > kScreenHeight - radius_) y_ = kScreenHeight - radius_;
}

bool Target::is_hit(int x, int y) {
  int dx = x - x_;
  int dy = y - y_;
  return dx * dx + dy * dy <= radius_ * radius_;
}

2.3 玩家类实现

玩家类主要包括玩家的位置、得分和剩余子弹数，以及玩家的移动和射击函数。

Player::Player() {
  x_ = kScreenWidth / 2;
  y_ = kScreenHeight / 2;
  score_ = 0;
  bullets_ = 10;
}

void Player::move(int dx, int dy) {
  x_ += dx;
  y_ += dy;
  if (x_ < kAimRadius) x_ = kAimRadius;
  if (x_ > kScreenWidth - kAimRadius) x_ = kScreenWidth - kAimRadius;
  if (y_ < kAimRadius) y_ = kAimRadius;
  if (y_ > kScreenHeight - kAimRadius) y_ = kScreenHeight - kAimRadius;
}

void Player::fire() {
  if (bullets_ > 0) {
    --bullets_;
    for (int i = 0; i < targets_.size(); ++i) {
      if (targets_[i].is_hit(x_, y_)) {
        ++score_;
        // Here should delete the hit target.
        break;
      }
    }
  }
}

2.4 游戏引擎实现

游戏引擎类主要包括游戏引擎的初始化、轮数的控制以及游戏进程的实现。

GameEngine::GameEngine() {
  round_ = 0;
  is_over_ = false;
}

void GameEngine::run() {
  while (!is_over_) {
    ++round_;
    targets_.clear();
    for (int i = 0; i < kTargetCount; ++i) {
      Target target;
      targets_.push_back(target);
    }
    player_ = Player();
    while (!player_.is_dead() && !targets_.empty()) {
      // Read player action.
      // Update player position.
      // Update targets position.
      // Detect collision between aim and targets.
      // Display the game screen.
    }
    // Display the score and ask whether to continue.
  }
}

3. 示例说明

3.1 箭头键控制瞄准器移动

在游戏引擎类的主循环中，可以检测用户是否按下了箭头键，并根据键盘输入来控制瞄准器的位置，例如：

while (!player_.is_dead() && !targets_.empty()) {
  int dx = 0, dy = 0;
  if (kbhit()) {
    int c = getch();
    if (c == 224) {
      c = getch();
      switch (c) {
        case 72: dy = -5; break; // Up arrow
        case 80: dy = 5; break; // Down arrow
        case 75: dx = -5; break; // Left arrow
        case 77: dx = 5; break; // Right arrow
        default: break;
      }
    } else if (c == 32) {
      player_.fire(); // Space key to fire
    }
  }
  player_.move(dx, dy);
  for (int i = 0; i < targets_.size(); ++i) {
    targets_[i].move();
  }
  // Detect collision between aim and targets.
  // Display the game screen.
}

3.2 目标移动轨迹的随机性

在目标类中的move函数中，可以利用rand函数来实现目标的随机移动轨迹，例如：

void Target::move() {
  int dx = speed_ * ((rand() % 3) - 1);
  int dy = speed_ * ((rand() % 3) - 1);
  x_ += dx;
  y_ += dy;
  if (x_ < radius_) x_ = radius_;
  if (x_ > kScreenWidth - radius_) x_ = kScreenWidth - radius_;
  if (y_ < radius_) y_ = radius_;
  if (y_ > kScreenHeight - radius_) y_ = kScreenHeight - radius_;
}