自创只有一道门游戏

userId_undefined
lkh1009（充电勿扰）
时间刺客空间掌握者时空双修者出道萌新倔强青铜快乐小狗

2026-04-19 08:56:09

发布于：福建

3阅读
0回复
0点赞
//只有一道门游戏
/*
游戏元素：

玩家(P)

墙壁(#)

怪物(M)

陷阱(T)

按钮(B)

门(D/X)

钥匙(K)
*/
//只有一道门游戏
/*
游戏元素：

玩家(P)

墙壁(#)

怪物(M)

陷阱(T)

按钮(B)

门(D/X)

钥匙(K)
*/
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <windows.h>

// 游戏常量定义
const int MAX_LEVELS = 1000;
const int MAP_WIDTH = 15;
const int MAP_HEIGHT = 10;

// 游戏元素类型
enum ElementType {
	EMPTY = 0,
	PLAYER = 1,
	MONSTER = 2,
	TRAP = 3,
	BUTTON = 4,
	DOOR = 5,
	WALL = 6
};

// 方向枚举
enum Direction {
	UP = 0,
	DOWN = 1,
	LEFT = 2,
	RIGHT = 3
};

// 游戏元素结构体
struct GameElement {
	int x, y;
	ElementType type;
	bool active;
	int data; // 额外数据（如陷阱状态、按钮关联的门等）
};

// 关卡结构体
struct Level {
	char name[50];
	int map[MAP_HEIGHT][MAP_WIDTH];
	GameElement elements[50];
	int elementCount;
	int playerIndex;
	int doorIndex;
	bool completed;
};

// 游戏状态结构体
struct GameState {
	Level levels[MAX_LEVELS];
	int currentLevel;
	int totalLevels;
	bool gameRunning;
};

// 函数声明
void initializeGame(GameState& game);
void initializeLevel(Level& level, int levelIndex);
void renderGame(const GameState& game);
void processInput(GameState& game);
void updateGame(GameState& game);
void movePlayer(Level& level, Direction dir);
void moveMonsters(Level& level);
void checkTraps(Level& level);
void checkButtonPress(Level& level);
void checkWinCondition(Level& level);
void showVictoryEffect();

// 初始化游戏
void initializeGame(GameState& game) {
	game.totalLevels = 1000; // 修改为1000关
	game.currentLevel = 0;
	game.gameRunning = true;
	
	srand(static_cast<unsigned int>(time(nullptr)));
	
	for (int i = 0; i < game.totalLevels; i++) {
		initializeLevel(game.levels[i], i);
	}
}

// 初始化关卡
void initializeLevel(Level& level, int levelIndex) {
	// 清空地图
	for (int y = 0; y < MAP_HEIGHT; y++) {
		for (int x = 0; x < MAP_WIDTH; x++) {
			level.map[y][x] = EMPTY;
		}
	}
	
	// 设置关卡名称
	sprintf(level.name, "Level %d  / 1000", levelIndex + 1);
	
	// 重置元素计数
	level.elementCount = 0;
	level.completed = false;
	
	// 添加墙壁边界
	for (int x = 0; x < MAP_WIDTH; x++) {
		level.map[0][x] = WALL;
		level.map[MAP_HEIGHT - 1][x] = WALL;
	}
	for (int y = 0; y < MAP_HEIGHT; y++) {
		level.map[y][0] = WALL;
		level.map[y][MAP_WIDTH - 1] = WALL;
	}
	
	// 添加一些内部墙壁
	for (int i = 0; i < 5 + levelIndex / 200; i++) { // 调整墙壁增长速度以适应1000关
		int x = rand() % (MAP_WIDTH - 2) + 1;
		int y = rand() % (MAP_HEIGHT - 2) + 1;
		level.map[y][x] = WALL;
	}
	
	// 添加玩家
	level.playerIndex = level.elementCount;
	level.elements[level.elementCount] = {1, 1, PLAYER, true, 0};
	level.map[1][1] = PLAYER;
	level.elementCount++;
	
	// 添加门
	level.doorIndex = level.elementCount;
	level.elements[level.elementCount] = {MAP_WIDTH - 2, MAP_HEIGHT - 2, DOOR, false, 0};
	level.map[MAP_HEIGHT - 2][MAP_WIDTH - 2] = DOOR;
	level.elementCount++;
	
	// 添加按钮
	level.elements[level.elementCount] = {MAP_WIDTH - 3, 2, BUTTON, true, level.doorIndex};
	level.map[2][MAP_WIDTH - 3] = BUTTON;
	level.elementCount++;
	
	// 添加陷阱 - 调整增长速度以适应1000关
	int trapCount = 2 + levelIndex / 100;
	if (trapCount > 10) trapCount = 10; // 适当提高陷阱数量上限
	
	for (int i = 0; i < trapCount; i++) {
		int x, y;
		do {
			x = rand() % (MAP_WIDTH - 2) + 1;
			y = rand() % (MAP_HEIGHT - 2) + 1;
		} while (level.map[y][x] != EMPTY);
		
		level.elements[level.elementCount] = {x, y, TRAP, true, 0};
		level.map[y][x] = TRAP;
		level.elementCount++;
	}
	
	// 添加怪兽 - 调整增长速度以适应1000关
	int monsterCount = 1 + levelIndex / 150;
	if (monsterCount > 8) monsterCount = 8; // 适当提高怪物数量上限
	
	for (int i = 0; i < monsterCount; i++) {
		int x, y;
		do {
			x = rand() % (MAP_WIDTH - 2) + 1;
			y = rand() % (MAP_HEIGHT - 2) + 1;
		} while (level.map[y][x] != EMPTY);
		
		level.elements[level.elementCount] = {x, y, MONSTER, true, 0};
		level.map[y][x] = MONSTER;
		level.elementCount++;
	}
}

// 渲染游戏
void renderGame(const GameState& game) {
	const Level& level = game.levels[game.currentLevel];
	
	// 清屏
#ifdef _WIN32
	system("cls");
#else
	system("clear");
#endif
	
	std::cout << "=== " << level.name << " ===" << std::endl;
	std::cout << "Controls: W/A/S/D to move, Q to quit" << std::endl;
	std::cout << "Progress: " << game.currentLevel + 1 << "/" << game.totalLevels << std::endl;
	std::cout << std::endl;
	
	// 渲染地图
	for (int y = 0; y < MAP_HEIGHT; y++) {
		for (int x = 0; x < MAP_WIDTH; x++) {
			char symbol = ' ';
			switch (level.map[y][x]) {
				case EMPTY: symbol = ' '; break;
				case PLAYER: symbol = 'P'; break;
				case MONSTER: symbol = 'M'; break;
				case TRAP: symbol = 'T'; break;
				case BUTTON: symbol = 'B'; break;
				case DOOR: 
				symbol = level.elements[level.doorIndex].active ? 'X' : 'D'; 
				break;
				case WALL: symbol = '#'; break;
			}
			std::cout << symbol;
		}
		std::cout << std::endl;
	}
	
	std::cout << std::endl;
	std::cout << "玩家(P) 墙壁(#) 怪物(M) 陷阱(T) 按钮(B) 门(D) 关闭门(X) 钥匙(K)" << std::endl;
}

// 处理输入
void processInput(GameState& game) {
	char input;
	std::cin >> input;
	
	Level& level = game.levels[game.currentLevel];
	
	switch (input) {
	case 'w': case 'W':
		movePlayer(level, UP);
		break;
	case 's': case 'S':
		movePlayer(level, DOWN);
		break;
	case 'a': case 'A':
		movePlayer(level, LEFT);
		break;
	case 'd': case 'D':
		movePlayer(level, RIGHT);
		break;
	case 'q': case 'Q':
		game.gameRunning = false;
		break;
	default:
		break;
	}
}

// 移动玩家
void movePlayer(Level& level, Direction dir) {
	GameElement& player = level.elements[level.playerIndex];
	int newX = player.x;
	int newY = player.y;
	
	switch (dir) {
		case UP: newY--; break;
		case DOWN: newY++; break;
		case LEFT: newX--; break;
		case RIGHT: newX++; break;
	}
	
	// 检查是否可以移动
	if (level.map[newY][newX] == WALL) {
		return; // 撞墙，不能移动
	}
	
	// 检查是否碰到陷阱
	if (level.map[newY][newX] == TRAP) {
		// 游戏结束逻辑
		std::cout << "You stepped on a trap! Game Over!" << std::endl;
		exit(0);
	}
	
	// 检查是否碰到怪兽
	if (level.map[newY][newX] == MONSTER) {
		// 游戏结束逻辑
		std::cout << "A monster got you! Game Over!" << std::endl;
		exit(0);
	}
	
	// 移动玩家
	level.map[player.y][player.x] = EMPTY;
	player.x = newX;
	player.y = newY;
	level.map[player.y][player.x] = PLAYER;
	
	// 检查是否按下按钮
	checkButtonPress(level);
	
	// 检查是否到达门
	checkWinCondition(level);
}

// 移动怪兽
void moveMonsters(Level& level) {
	for (int i = 0; i < level.elementCount; i++) {
		if (level.elements[i].type == MONSTER && level.elements[i].active) {
			GameElement& monster = level.elements[i];
			
			// 简单的AI：随机移动
			Direction dir = static_cast<Direction>(rand() % 4);
			int newX = monster.x;
			int newY = monster.y;
			
			switch (dir) {
				case UP: newY--; break;
				case DOWN: newY++; break;
				case LEFT: newX--; break;
				case RIGHT: newX++; break;
			}
			
			// 检查是否可以移动
			if (level.map[newY][newX] == EMPTY) {
				level.map[monster.y][monster.x] = EMPTY;
				monster.x = newX;
				monster.y = newY;
				level.map[monster.y][monster.x] = MONSTER;
			}
			
			// 检查是否碰到玩家
			if (monster.x == level.elements[level.playerIndex].x && 
				monster.y == level.elements[level.playerIndex].y) {
				std::cout << "A monster got you! Game Over!" << std::endl;
				exit(0);
			}
		}
	}
}

// 检查陷阱
void checkTraps(Level& level) {
	// 在这个简化版本中，陷阱是静态的
	// 更复杂的版本可以在这里实现陷阱的变化逻辑
}

// 检查按钮按下
void checkButtonPress(Level& level) {
	GameElement& player = level.elements[level.playerIndex];
	
	for (int i = 0; i < level.elementCount; i++) {
		if (level.elements[i].type == BUTTON && level.elements[i].active) {
			if (player.x == level.elements[i].x && player.y == level.elements[i].y) {
				// 按下按钮，打开对应的门
				int doorIndex = level.elements[i].data;
				level.elements[doorIndex].active = false;
				level.elements[i].active = false; // 按钮只能按一次
				level.map[level.elements[i].y][level.elements[i].x] = EMPTY;
				
				std::cout << "Button pressed! The door is now open!" << std::endl;
			}
		}
	}
}

// 检查胜利条件
void checkWinCondition(Level& level) {
	GameElement& player = level.elements[level.playerIndex];
	GameElement& door = level.elements[level.doorIndex];
	
	if (!door.active && player.x == door.x && player.y == door.y) {
		level.completed = true;
	}
}

// 更新游戏状态
void updateGame(GameState& game) {
	Level& level = game.levels[game.currentLevel];
	
	moveMonsters(level);
	checkTraps(level);
	
	// 检查是否完成当前关卡
	if (level.completed) {
		game.currentLevel++;
		if (game.currentLevel >= game.totalLevels) {
			std::cout << "You've completed all 1000 levels! You are a true champion!" << std::endl;
			game.gameRunning = false;
		} else {
			std::cout << "Moving to next level.";
			Sleep (1000);
			std::cout << ".";
			Sleep (1000);
			std::cout << ".";
			Sleep (1000);
		}
	}
}

// 主游戏循环
int main() {
SetConsoleTitle("只有一道门游戏");
	GameState game;
	initializeGame(game);
	
	while (game.gameRunning) {
		renderGame(game);
		processInput(game);
		updateGame(game);
	}
	
	std::cout << "Thanks for playing!" << std::endl;
	
	return 0;
}
userId_undefined
去预览
0/2000
暂无数据

这里空空如也

热门讨论