三維迷宮遊戲
《三維迷宮》遊戲規則大綱——又名《在迷宮裏找不着北指南》
🎮 遊戲基本設定
一句話介紹：你，一個可憐的探險家，被困在了一個10層的三維迷宮裏。好消息是出口就在最底層右下角，壞消息是——你得先找到10把鑰匙才能出去。祝你好運，別把自己繞暈了！
🗺️ 地圖規則
1. 三層立體地獄
迷宮有10層，每層20×20大小
每層都有配對樓梯（↑=上樓，↓=下樓），但別指望它們總在你需要的地方
記住：如果這層有下樓樓梯（↑），樓上同一位置一定是上樓樓梯（↓）——除非生成算法抽風了
2. 視覺限制
你只能看到周圍5×5的區域
再遠的地方？抱歉，那是“迷霧”——設計師稱之為“增加神秘感”，你稱之為“這破遊戲故意坑我”
邊界提示會告訴你“再往前就是萬丈深淵”——其實是數組越界
🔑 鑰匙收集規則
1. 數量要求
需要收集10把鑰匙才能打開出口大門
鑰匙隨機散佈在10層迷宮中
温馨提示：有些鑰匙可能就在你起點旁邊，也可能藏在某個你永遠找不到的角落——這取決於RNG（隨機數之神）今天的心情
2. 收集方式
走到鑰匙上按E鍵收集
收集時有成就感滿滿的提示音——好吧，其實是文字提示
每把鑰匙都是獨一無二的，但長得都一樣，就像迷宮裏的每一面牆
🚶♂️ 移動規則
1. 基礎移動（WASD大法）
W：向上走——除非上面是牆
A：向左走——除非左邊是牆
S：向下走——除非下面是牆
D：向右走——除非右邊是牆
温馨提示：如果你發現哪個方向都走不了，恭喜你，你可能被牆包圍了。重啓遊戲吧，不丟人。
2. 垂直移動（上下樓技巧）
站在上樓樓梯（↑） 上按Q：上一層樓
站在下樓樓梯（↓） 上按Z：下一層樓
重要提醒：不能穿地板！ 你不能直接從第5層跳到第1層，得一層層爬——就像現實中的樓梯一樣，驚不驚喜？
🔮 技能系統（你的救命稻草）
1. 鑰匙探測技能（按1鍵激活）
效果：顯示離你最近的鑰匙位置和具體移動路徑——對了，路徑指示會穿牆，可你不會！
持續時間：10秒——足夠你找到方向，不夠你走到目的地
冷卻時間：30秒——設計師説“要平衡”，你説“這也太長了吧！”
2. 技能提示示例
“W(向上)走3步”——簡單明瞭
“前往樓梯：D(向右)走5步”——先找樓梯，再換層
“按Q鍵上樓”——你已經站在樓梯上了，還等什麼？
“未找到鑰匙”——要麼鑰匙收完了，要麼RNG今天特別調皮
🏁 勝利條件
1. 前提條件
收集全部10把鑰匙（少一把/多一把都不行，大門很挑剔）
找到出口（第10層右下角，座標18,18）
2. 通關流程
收集10把鑰匙（過程中請保持耐心，罵街請小聲）→ 來到第10層右下角（建議使用技能導航）→ 站在出口（★）上 → 看到勝利提示 → 按任意鍵退出——或者再玩一局，如果你有受虐傾向
⚠️ 重要警告
不要試圖穿牆——代碼會阻止你，現實中的牆也會
不要迷路——雖然這幾乎是必然的
不要忘記技能冷卻——按了1沒反應？等30秒再來
不要質疑迷宮生成算法——它盡力了，真的
😂 提示
如果遊戲一開始你就在牆上——恭喜，你中獎了！請重啓
如果找不到鑰匙——試試技能，或者閉上眼睛祈禱
如果還是找不到——也許鑰匙就在你剛才經過的地方
如果徹底迷路——記住，上下樓樓梯是成對出現的，找到一對就找到了希望
🎯 最後一條規則
最重要的規則：玩得開心！如果遇到BUG，請微笑面對——畢竟在三維迷宮裏，連BUG都顯得那麼立體。
遊戲設計師寄語：
“我們設計這個迷宮時，自己都經常迷路。
如果你能通關，請接受我們最誠摯的敬意——
以及一張‘三維空間方向感大師’的虛擬證書。”
祝你探險愉快！ 🗝️🧭🎮
作者的話（嗯對這個是真正的）
相信你已經發現了，上面的規則不是作者本人寫的
而是Deep Seek
懂得都懂，這個代碼只有一部分是作者寫的（靈感+生成三維地圖的一部分+玩家基礎操作（w a s d ）+玩家技能的一部分+鑰匙生成的一部分，也就是約50%
剩下的是Deep Seek寫的
）
代碼（我知道你們只看這裏）
#include <bits/stdc++.h>
#include <windows.h>
#include <conio.h>
using namespace std;
struct PLAYER {
int x, y, z;
vector<string> artic;
};
char mapa[10][20][20];
bool vis[10][20][20];
int fx[4][2] = {{2, 0}, {-2, 0}, {0, 2}, {0, -2}};
int zj[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool v[10][20][20] = {0};
// 計算兩個座標之間的曼哈頓距離（包括跨層）
int manhattanDistance(int x1, int y1, int z1, int x2, int y2, int z2) {
return abs(x1 - x2) + abs(y1 - y2) + abs(z1 - z2);
}
// 全局變量修改
bool skill_active = false;
int skill_cooldown = 0;
int skill_duration = 0;
int skill_start_time = 0;
string skill_hint = "";
int target_key_x = -1, target_key_y = -1, target_key_z = -1; // 當前目標鑰匙位置
// 查找所有鑰匙，返回最近鑰匙的位置
bool findNearestKeyPosition(int player_x, int player_y, int player_z, int &key_x, int &key_y, int &key_z) {
int min_distance = 9999;
bool found = false;
// 遍歷所有位置尋找最近的鑰匙
for(int x = 0; x < 10; x++) {
for(int y = 0; y < 20; y++) {
for(int z = 0; z < 20; z++) {
if(mapa[x][y][z] == 'K') {
int distance = manhattanDistance(player_x, player_y, player_z, x, y, z);
if(distance < min_distance) {
min_distance = distance;
key_x = x;
key_y = y;
key_z = z;
found = true;
}
}
}
}
}
return found;
}
// 修復findNearestStair函數中的參數傳遞問題
bool findNearestStair(int player_x, int player_y, int player_z, int target_floor,
int &stair_x, int &stair_y, int &stair_z, char &stair_type) {
int min_distance = 9999;
bool found = false;
// 修正：循環變量應該是y和z，但我們需要查找的是樓梯位置
for(int y = 1; y < 19; y++) { // 從1到18，避開邊界
for(int z = 1; z < 19; z++) {
if(target_floor < player_x) {
// 需要上樓，找當前層的U
if(mapa[player_x][y][z] == 'U') {
int distance = manhattanDistance(player_x, player_y, player_z, player_x, y, z);
if(distance < min_distance) {
min_distance = distance;
stair_x = player_x;
stair_y = y;
stair_z = z;
stair_type = 'U';
found = true;
}
}
} else if(target_floor > player_x) {
// 需要下樓，找當前層的D
if(mapa[player_x][y][z] == 'D') {
int distance = manhattanDistance(player_x, player_y, player_z, player_x, y, z);
if(distance < min_distance) {
min_distance = distance;
stair_x = player_x;
stair_y = y;
stair_z = z;
stair_type = 'D';
found = true;
}
}
}
}
}
return found;
}
string getNextStepHint(int player_x, int player_y, int player_z,
int target_x, int target_y, int target_z) {
// 如果目標就是當前位置
if(player_x == target_x && player_y == target_y && player_z == target_z) {
return "目標已到達！按E鍵收集鑰匙";
}
// 1. 先檢查是否需要換層
if(player_x != target_x) {
int stair_x, stair_y, stair_z;
char stair_type;
// 尋找最近的樓梯
if(findNearestStair(player_x, player_y, player_z, target_x,
stair_x, stair_y, stair_z, stair_type)) {
// 如果在樓梯上
if(player_x == stair_x && player_y == stair_y && player_z == stair_z) {
if(stair_type == 'U') return "按Q鍵上樓";
else return "按Z鍵下樓";
}
// 需要移動到樓梯
char buffer[100];
// 先判斷垂直方向（y座標）
if(stair_y < player_y) {
// 樓梯在上方
int steps = player_y - stair_y;
sprintf(buffer, "前往樓梯：W(向上)走%d步", steps);
} else if(stair_y > player_y) {
// 樓梯在下方
int steps = stair_y - player_y;
sprintf(buffer, "前往樓梯：S(向下)走%d步", steps);
}
// 如果y座標相同，判斷水平方向（z座標）
else if(stair_z < player_z) {
// 樓梯在左方
int steps = player_z - stair_z;
sprintf(buffer, "前往樓梯：A(向左)走%d步", steps);
} else if(stair_z > player_z) {
// 樓梯在右方
int steps = stair_z - player_z;
sprintf(buffer, "前往樓梯：D(向右)走%d步", steps);
} else {
return "前往樓梯：已在樓梯位置";
}
return string(buffer);
} else {
// 沒有找到樓梯，應該不會發生，但為了安全
return "尋找樓梯...";
}
}
// 2. 同一層內，直接指引到鑰匙
char buffer[100];
// 優先垂直方向移動
if(target_y < player_y) {
// 鑰匙在上方
int steps = player_y - target_y;
sprintf(buffer, "W(向上)走%d步", steps);
} else if(target_y > player_y) {
// 鑰匙在下方
int steps = target_y - player_y;
sprintf(buffer, "S(向下)走%d步", steps);
}
// 然後水平方向移動
else if(target_z < player_z) {
// 鑰匙在左方
int steps = player_z - target_z;
sprintf(buffer, "A(向左)走%d步", steps);
} else if(target_z > player_z) {
// 鑰匙在右方
int steps = target_z - player_z;
sprintf(buffer, "D(向右)走%d步", steps);
} else {
// 如果x,y,z都相同，但前面已經檢查過這種情況
return "目標已到達！按E鍵收集";
}
return string(buffer);
}
// 更新技能提示（每幀調用）
void updateSkillHint(int player_x, int player_y, int player_z) {
if(!skill_active) return;
// 檢查技能是否過期
int current_time = GetTickCount();
if(current_time - skill_start_time > 10000) {
skill_active = false;
skill_hint = "";
return;
}
// 重新查找最近的鑰匙（動態更新目標）
int nearest_x, nearest_y, nearest_z;
if(findNearestKeyPosition(player_x, player_y, player_z, nearest_x, nearest_y, nearest_z)) {
// 如果找到了新目標，或者目標已不存在，更新目標
if(nearest_x != target_key_x || nearest_y != target_key_y || nearest_z != target_key_z) {
target_key_x = nearest_x;
target_key_y = nearest_y;
target_key_z = nearest_z;
}
// 更新提示
skill_hint = getNextStepHint(player_x, player_y, player_z,
target_key_x, target_key_y, target_key_z);
skill_duration = 10 - (current_time - skill_start_time) / 1000;
} else {
skill_hint = "未找到鑰匙";
}
}
void updateSkillStatus(int player_x, int player_y, int player_z) {
// 更新冷卻時間
if(skill_cooldown > 0) {
skill_cooldown--;
}
// 如果技能激活，更新提示
if(skill_active) {
updateSkillHint(player_x, player_y, player_z);
}
}
// 另外，修改useSkill函數，確保skill_hint被正確設置
bool useSkill(int player_x, int player_y, int player_z) {
if(skill_cooldown > 0) {
char cool_down_msg[50];
// 注意：skill_cooldown是幀數，除以10得到秒數
sprintf(cool_down_msg, "技能冷卻中... 剩餘%.1f秒", skill_cooldown/10.0);
skill_hint = cool_down_msg;
return false;
}
// 激活技能
skill_active = true;
skill_start_time = GetTickCount();
skill_duration = 10;
skill_cooldown = 300; // 30秒 * 10幀/秒 = 300幀
// 重置目標鑰匙
target_key_x = target_key_y = target_key_z = -1;
// 初始查找目標
updateSkillHint(player_x, player_y, player_z);
return true;
}
void init(int z) {
for(int i = 0; i < 20; i++) {
for(int j = 0; j < 20; j++) {
mapa[z][i][j] = '#';
}
}
for(int i = 0; i < 20; i++) {
mapa[z][0][i] = '#';
mapa[z][19][i] = '#';
mapa[z][i][0] = '#';
mapa[z][i][19] = '#';
}
}
void dfs(int z, int x, int y) {
mapa[z][x][y] = '.';
v[z][x][y] = true;
int directions[4] = {0, 1, 2, 3};
for(int i = 0; i < 4; i++) {
int j = rand() % 4;
swap(directions[i], directions[j]);
}
for(int d = 0; d < 4; d++) {
int dir = directions[d];
int nx = x + fx[dir][0];
int ny = y + fx[dir][1];
int wx = x + zj[dir][0];
int wy = y + zj[dir][1];
if(nx > 0 && nx < 19 && ny > 0 && ny < 19) {
if(mapa[z][nx][ny] == '#') {
mapa[z][wx][wy] = '.';
dfs(z, nx, ny);
}
}
}
}
// 強制打通到右下角的路徑
void forcePathToBottomRight(int z) {
// 從(1,1)開始，強制打通一條到(17,17)的路徑
int x = 1, y = 1;
// 先向右移動
while(y < 17) {
mapa[z][x][y+1] = '.';
mapa[z][x][y+2] = '.';
y += 2;
}
// 再向下移動
while(x < 17) {
mapa[z][x+1][y] = '.';
mapa[z][x+2][y] = '.';
x += 2;
}
// 確保(18,18)可達（奇數座標）
mapa[z][18][18] = '.';
mapa[z][17][18] = '.';
mapa[z][18][17] = '.';
}
void generatePairedStairs() {
// 每層生成的樓梯對數（1-2對）
for(int z = 0; z < 9; z++) {
int stair_pairs = 1 + rand() % 2;
for(int p = 0; p < stair_pairs; p++) {
int stair_x, stair_y;
int attempts = 0;
do {
stair_x = (rand() % 9) * 2 + 1;
stair_y = (rand() % 9) * 2 + 1;
attempts++;
} while((mapa[z][stair_x][stair_y] != '.' ||
mapa[z+1][stair_x][stair_y] != '.') && attempts < 50);
if(attempts < 50) {
mapa[z][stair_x][stair_y] = 'D';
mapa[z+1][stair_x][stair_y] = 'U';
}
}
}
// 確保第一層有下樓樓梯
bool has_down_from_first = false;
for(int i = 1; i < 19; i += 2) {
for(int j = 1; j < 19; j += 2) {
if(mapa[0][i][j] == 'D') {
has_down_from_first = true;
break;
}
}
if(has_down_from_first) break;
}
if(!has_down_from_first) {
int x, y;
do {
x = (rand() % 9) * 2 + 1;
y = (rand() % 9) * 2 + 1;
} while(mapa[0][x][y] != '.' || mapa[1][x][y] != '.');
mapa[0][x][y] = 'D';
mapa[1][x][y] = 'U';
}
}
// 確保最後一層右下角可達並設置出口
void setExitAtBottomRight() {
int z = 9; // 最後一層
// 首先確保右下角區域是通路
// 將(18,18)設置為通路（因為迷宮座標是0-19，18是最大的奇數座標）
int target_x = 18, target_y = 18;
// 如果目標點不是通路，打通它
if(mapa[z][target_x][target_y] != '.') {
// 打通目標點和周圍必要的牆壁
mapa[z][target_x][target_y] = '.';
// 打通周圍的牆壁以確保可達
if(target_x > 1 && mapa[z][target_x-1][target_y] == '#') {
mapa[z][target_x-1][target_y] = '.';
}
if(target_y > 1 && mapa[z][target_x][target_y-1] == '#') {
mapa[z][target_x][target_y-1] = '.';
}
}
// 在最後一層強制打通一條到右下角的路徑
forcePathToBottomRight(z);
// 設置出口在右下角
mapa[z][target_x][target_y] = 'E';
// 確保出口周圍可通行
for(int dx = -1; dx <= 1; dx++) {
for(int dy = -1; dy <= 1; dy++) {
if(abs(dx) + abs(dy) == 1) { // 上下左右四個方向
int nx = target_x + dx;
int ny = target_y + dy;
if(nx >= 1 && nx <= 18 && ny >= 1 && ny <= 18) {
if(mapa[z][nx][ny] == '#') {
mapa[z][nx][ny] = '.';
}
}
}
}
}
}
// 修改鑰匙生成函數
void generateKeys() {
for(int i=1;i<=10;i++){ // 設置10把鑰匙
int kx,ky,kz;
do{
kx = rand()%10; // 層 0-9
ky = (rand()%9)*2+1; // 行，保證是奇數（通路）
kz = (rand()%9)*2+1; // 列，保證是奇數（通路）
}while(mapa[kx][ky][kz]!='.' || // 必須放在通路上
(kx==0 && ky==1 && kz==1) || // 不能放在起點
(kx==9 && ky==18 && kz==18)); // 不能放在出口
mapa[kx][ky][kz]='K';
}
}
// 在generateMaze()函數中添加
void generateMaze() {
srand(time(NULL));
// 逐層生成迷宮
for(int z = 0; z < 10; z++) {
init(z);
for(int i = 0; i < 20; i++) {
for(int j = 0; j < 20; j++) {
v[z][i][j] = false;
}
}
int start_x = (rand() % 9) * 2 + 1;
int start_y = (rand() % 9) * 2 + 1;
dfs(z, start_x, start_y);
// 在第0層強制打通到起點的路徑
if(z == 0) {
// 確保起點(1,1)是通路
mapa[z][1][1] = '.';
mapa[z][1][2] = '.';
mapa[z][2][1] = '.';
}
}
// 生成配對的樓梯
generatePairedStairs();
// 設置起點和終點
mapa[0][1][1] = 'P'; // 玩家起點在左上角
setExitAtBottomRight(); // 終點在最後一層右下角
// 生成鑰匙
generateKeys(); // 添加這行
}
// 修改printFloor函數，添加技能激活時的完整顯示
void printFloor(int z, int player_x, int player_y, int count) {
cout << "第 " << z + 1 << " 層，當前位置(" << player_x << "," << player_y << ")" << endl;
cout << "■=牆 .=路 ○=你 ★=出口 ↑=上樓 ↓=下樓 ▲=鑰匙" << endl;
cout << "----------------------------------------" << endl;
// 顯示技能狀態 - 修改後的完整版本
cout << "技能：按1鍵探測最近鑰匙";
if(skill_cooldown > 0) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
// 確保顯示正確的冷卻時間
double cool_time = skill_cooldown / 10.0;
cout << " [冷卻：" << fixed << setprecision(1) << cool_time << "秒]";
} else {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
cout << " [就緒]";
}
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
cout << endl;
// 如果技能激活，顯示提示 - 添加這部分
if(skill_active) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout << "鑰匙探測中... " << skill_duration << "秒" << endl;
cout << "提示：" << skill_hint << endl;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
}
cout << "----------------------------------------" << endl;
// 計算顯示區域的邊界
int start_i = max(player_x - 2, 0);
int end_i = min(player_x + 2, 19);
int start_j = max(player_y - 2, 0);
int end_j = min(player_y + 2, 19);
// 顯示y座標
cout << " y→";
for(int j = start_j; j <= end_j; j++) {
if(j == player_y) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
cout << setw(3) << j;
} else {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
cout << setw(3) << j;
}
}
cout << endl;
// 顯示地圖內容
for(int i = start_i; i <= end_i; i++) {
// 顯示x座標
if(i == player_x) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
cout << setw(3) << i << "x ";
} else {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
cout << setw(3) << i << " ";
}
// 顯示地圖內容
for(int j = start_j; j <= end_j; j++) {
char c = mapa[z][i][j];
if(i == player_x && j == player_y) {
// 玩家當前位置
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
cout << "○ ";
} else if(c == '#') {
// 牆
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 8);
cout << "■ ";
} else if(c == '.') {
// 路
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
cout << "· ";
} else if(c == 'P') {
// 起點
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11);
cout << "S ";
} else if(c == 'E') {
// 出口
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 12);
cout << "★ ";
} else if(c == 'U') {
// 上樓
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 14);
cout << "↑ ";
} else if(c == 'D') {
// 下樓
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 13);
cout << "↓ ";
} else if(c == 'K') {
//鑰匙
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 2);
cout << "▲ ";
}
}
cout << endl;
}
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
cout << "----------------------------------------" << endl;
// 顯示當前位置的詳細信息
cout << "\n當前位置信息：" << endl;
char current_cell = mapa[z][player_x][player_y];
if(current_cell == '#') {
cout << "你在牆上（如果發生，請重啓）" << endl;
} else if(current_cell == '.') {
cout << "你在通道上" << endl;
} else if(current_cell == 'P') {
cout << "你在起點位置" << endl;
} else if(current_cell == 'E') {
cout << "你到達了出口！" << endl;
cout<<"恭喜你，你贏了！" <<endl;
} else if(current_cell == 'U') {
cout << "你在上樓樓梯處（按Q鍵上樓）" << endl;
} else if(current_cell == 'D') {
cout << "你在下樓樓梯處（按Z鍵下樓）" << endl;
} else if(current_cell == 'K'){
cout << "你在鑰匙上（按E鍵收集）" <<endl;
}
cout << "\n當前鑰匙數量：" << count << "/10" << endl;
// 顯示視野邊界信息
if(start_i == 0) cout << "↑北邊是邊界" << endl;
if(end_i == 19) cout << "↓南邊是邊界" << endl;
if(start_j == 0) cout << "←西邊是邊界" << endl;
if(end_j == 19) cout << "→東邊是邊界" << endl;
}
bool canMove(int x,int y,int z){
if(mapa[x][y][z]!='#'&&x>=0&&x<10&&y>=0&&y<20&&z>=0&&z<20)return 1;
return 0;
}
int main() {
char k;
int count = 0;
// 初始化隨機種子
srand(time(NULL));
generateMaze();
PLAYER player={0,1,1};
// 初始化技能開始時間
skill_start_time = GetTickCount();
// 記錄總共需要多少鑰匙
const int TOTAL_KEYS = 10;
while(1){
system("cls");
printFloor(player.x, player.y, player.z, count);
updateSkillStatus(player.x, player.y, player.z);
// 檢查是否在出口上且鑰匙足夠
if(mapa[player.x][player.y][player.z] == 'E') {
if(count >= TOTAL_KEYS){
cout << "\n恭喜你收集了所有鑰匙！" << endl;
cout << "按任意鍵退出..." << endl;
_getch();
break;
}
else{
cout << "\n你還未收集完所有鑰匙！" << endl;
cout << "需要 " << TOTAL_KEYS << " 把鑰匙，當前只有 " << count << " 把" << endl;
cout << "按任意鍵繼續遊戲..." << endl;
_getch();
// 這裏不要break，讓玩家繼續遊戲
}
}
if (kbhit()){
k=_getch();
k = tolower(k);
int nx = player.x;
int ny = player.y;
int nz = player.z;
if(k == '1') {
useSkill(player.x, player.y, player.z);
// 刷新顯示
system("cls");
printFloor(player.x, player.y, player.z, count);
cout << "\n技能已激活！10秒內顯示最近鑰匙方向" << endl;
Sleep(1000);
continue; // 跳過後續移動處理
}
switch(k){
case 'a':{ // 左
nz--;
break;
}
case 'd':{ // 右
nz++;
break;
}
case 'w':{ // 上
ny--;
break;
}
case 's':{ // 下
ny++;
break;
}
case 'q':{ // 上樓
if(mapa[player.x][player.y][player.z] == 'U' && player.x > 0){
nx--;
}
break;
}
case 'z':{ // 下樓
if(mapa[player.x][player.y][player.z] == 'D' && player.x < 9){
nx++;
}
break;
}
case 'e':{ // 收集鑰匙
if(mapa[player.x][player.y][player.z] == 'K'){
mapa[player.x][player.y][player.z]='.';
count++;
cout << "收集到一把鑰匙！(" << count << "/" << TOTAL_KEYS << ")" << endl;
Sleep(1000);
}
break;
}
}
// 檢查移動是否合法
if(canMove(nx, ny, nz)){
player.x = nx;
player.y = ny;
player.z = nz;
}
}
Sleep(100);
}
return 0;
}本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。
