Unten finden Sie ein komplexes C++-Puzzlespiel namens „Number Maze“, bei dem der Spieler ein Labyrinth lösen muss, indem er Zahlen verschiebt.
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <ctime>
#include <cstdlib>
class NumberMaze {
private:
std::vector<std::vector<int>> maze;
std::pair<int, int> playerPos;
int stepsCount;
int targetNumber;
public:
NumberMaze(int size)
: maze(size, std::vector<int>(size)), stepsCount(0) {
}
void generateMaze() {
srand(static_cast<unsigned>(time(nullptr)));
int size = maze.size();
// Generate random numbers for the maze
std::vector<int> numbers;
for (int i = 0; i < size * size; i++) {
numbers.push_back(i);
}
std::random_shuffle(numbers.begin(), numbers.end());
// Fill in the maze with numbers
int index = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
maze[i][j] = numbers[index++];
}
}
// Set player position and target number
playerPos = std::make_pair(size - 1, size - 1);
targetNumber = 0;
}
void displayMaze() const {
int size = maze.size();
// Display the maze
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (i == playerPos.first && j == playerPos.second) {
std::cout << " P ";
} else {
std::cout << " " << maze[i][j] << " ";
}
}
std::cout << std::endl;
}
// Display the steps count and target number
std::cout << "Steps: " << stepsCount << std::endl;
std::cout << "Target: " << targetNumber << std::endl;
std::cout << std::endl;
}
bool isGameOver() const {
int size = maze.size();
return playerPos == std::make_pair(0, 0) && maze[0][0] == targetNumber;
}
bool isValidMove(int row, int col) const {
int size = maze.size();
return row >= 0 && row < size && col >= 0 && col < size && maze[row][col] <= targetNumber;
}
void makeMove(int row, int col) {
if (isValidMove(row, col)) {
playerPos = std::make_pair(row, col);
stepsCount++;
targetNumber = std::max(targetNumber, maze[row][col]);
} else {
std::cout << "Invalid move!" << std::endl;
}
}
};
int main() {
int size;
std::cout << "Enter the size of the maze: ";
std::cin >> size;
NumberMaze game(size);
game.generateMaze();
while (!game.isGameOver()) {
game.displayMaze();
int row, col;
std::cout << "Enter the row and column to move: ";
std::cin >> row >> col;
game.makeMove(row, col);
}
std::cout << "Congratulations! You solved the maze in " << game.getStepsCount() << " steps." << std::endl;
return 0;
}
Das „Number Maze“-Spiel in diesem Beispiel ist ein Zahlen-Puzzlespiel. Der Spieler muss das Labyrinth durch Bewegen lösen. Das Labyrinth ist mit Zahlen gefüllt, die Ausgangsposition des Spielers ist die untere rechte Ecke des Labyrinths und das Ziel besteht darin, in die obere linke Ecke des Labyrinths zu gelangen und die Zielzahl zu erreichen. Der Spieler kann sich nur auf eine Position bewegen, die kleiner als die Zielzahl ist. Nach jedem Zug wird die Schrittzahl des Spielers erhöht und die Zielzahl auf den größeren Wert aus der Nummer der aktuellen Position und der Zielzahl aktualisiert.
Der Spieler kann sich an eine beliebige Stelle im Labyrinth bewegen, muss sich dabei jedoch an die folgenden Regeln halten:
- Bewegungen sind nur oberhalb, unterhalb, links oder rechts des Labyrinths möglich, diagonale Bewegungen sind nicht möglich.
- Züge können nur zu Positionen gehen, deren Zahl kleiner oder gleich der Zielzahl ist.
Die Endbedingung des Spiels besteht darin, dass sich der Spieler in die obere linke Ecke des Labyrinths bewegt und die Zahl an dieser Position der Zielzahl entspricht.
Während des Spiels wird der aktuelle Zustand des Labyrinths angezeigt, einschließlich der Position des Spielers, der Schrittzahl und der Zielnummer. Die Spieler müssen auf der Grundlage dieser Informationen ihre Schritte ausführen.
Sobald der Spieler das Labyrinth gelöst hat, wird die Anzahl der zurückgelegten Schritte angezeigt.
Dieses Beispiel für ein komplexes Puzzlespiel zeigt, wie man mithilfe der C++-Programmierung ein interaktives Spiel erstellt, das Strategie und Überlegung erfordert. Die Spieler müssen eine Bewegungsstrategie entwickeln, um das Labyrinth mit möglichst wenigen Schritten zu lösen.