中文马里奥
2026-07-26 15:28:03
发布于：浙江
2阅读
0回复
0点赞
#include<iostream>
#include<conio.h>
#include<windows.h>
#include<cstdlib>
#include<ctime>
#include<vector>
#include<string>
using namespace std;
const int WIDTH = 50;
const int HEIGHT = 20;
const int MAP_WIDTH = 80;
const int MAX_LIVES = 5;
const int TOTAL_LEVELS = 8;
int playerX = 5, playerY = 15;
int score = 0;
int lives = 3;
bool gameOver = false;
bool isJumping = false;
int jumpVelocity = 0;
const int MAX_JUMP = 6;
int frameCount = 0;
bool isInvincible = false;
int invincibleTimer = 0;
const int INVINCIBLE_DURATION = 60;
int flashCounter = 0;
int currentLevel = 0;
int respawnX = 3, respawnY = 16;
bool levelComplete = false;
int finishX = 75;
int cameraX = 0;
int stuckCounter = 0;
const int STUCK_THRESHOLD = 30;
int lastPlayerX = -1, lastPlayerY = -1;
struct PowerUp {
int x, y;
int type;
bool active;
};
struct Tile {
int x, y;
int type;
bool solid;
};
struct Cloud {
int x, y;
int size;
};
vector<PowerUp> powerUps;
vector<Tile> tiles;
vector<Cloud> clouds;
char screenBuffer[HEIGHT][WIDTH + 1];
void setConsoleFast() {
HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode;
GetConsoleMode(hInput, &mode);
mode &= ~ENABLE_QUICK_EDIT_MODE;
mode |= ENABLE_WINDOW_INPUT;
SetConsoleMode(hInput, mode);
}
void gotoxy(int x, int y) {
COORD coord;
coord.X = x;
coord.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}
void hideCursor() {
CONSOLE_CURSOR_INFO cursorInfo;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursorInfo);
cursorInfo.bVisible = false;
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursorInfo);
}
bool isSolid(int x, int y) {
if (x < 0 || x >= MAP_WIDTH || y < 0 || y >= HEIGHT) {
return false;
}
for (int i = 0; i < (int)tiles.size(); i++) {
if (tiles[i].solid && tiles[i].x == x && tiles[i].y == y) {
return true;
}
}
return false;
}
bool isGround(int x, int y) {
return isSolid(x, y);
}
int getGroundY(int x) {
for (int y = HEIGHT - 1; y >= 0; y--) {
if (isGround(x, y)) {
return y;
}
}
return HEIGHT - 1;
}
bool isPlayerStuck() {
if (isSolid(playerX, playerY)) {
return true;
}
return false;
}
void forceUnstuck() {
for (int y = playerY - 1; y >= 0; y--) {
if (!isSolid(playerX, y)) {
playerY = y;
isJumping = false;
jumpVelocity = 0;
system("color 0E");
Sleep(50);
system("color 0A");
gotoxy(0, HEIGHT + 4);
cout << "[!] 已脱离卡死！ ";
return;
}
}
for (int x = playerX - 1; x >= 0; x--) {
if (!isSolid(x, playerY)) {
playerX = x;
isJumping = false;
jumpVelocity = 0;
system("color 0E");
Sleep(50);
system("color 0A");
gotoxy(0, HEIGHT + 4);
cout << "[!] 已脱离卡死！ ";
return;
}
}
playerX = respawnX;
playerY = respawnY;
isJumping = false;
jumpVelocity = 0;
system("color 0E");
Sleep(50);
system("color 0A");
gotoxy(0, HEIGHT + 4);
cout << "[!] 已重置到出生点！ ";
}
void createGround(int startX, int endX, int y) {
for (int x = startX; x <= endX; x++) {
Tile t;
t.x = x;
t.y = y;
t.type = 1;
t.solid = true;
tiles.push_back(t);
}
}
void createBrick(int startX, int endX, int y) {
for (int x = startX; x <= endX; x++) {
Tile t;
t.x = x;
t.y = y;
t.type = 2;
t.solid = true;
tiles.push_back(t);
}
}
void createHole(int x, int width) {
for (int i = 0; i < width; i++) {
for (int j = 0; j < (int)tiles.size(); j++) {
if (tiles[j].x == x + i && tiles[j].y == 17) {
tiles[j].solid = false;
tiles[j].type = 0;
}
}
}
}
void createFinish(int x, int y) {
Tile flag;
flag.x = x;
flag.y = y;
flag.type = 3;
flag.solid = false;
tiles.push_back(flag);
}
void addPowerUp(int x, int y, int type) {
PowerUp p;
p.x = x;
p.y = y;
p.type = type;
p.active = true;
powerUps.push_back(p);
}
void generateClouds() {
clouds.clear();
for (int i = 0; i < 15; i++) {
Cloud c;
c.x = rand() % MAP_WIDTH;
c.y = 2 + rand() % 5;
c.size = 3 + rand() % 6;
clouds.push_back(c);
}
}
// ============================================================
// 关卡1：草原
// ============================================================
void loadLevel1() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 12, 17);
createGround(16, 20, 17);
createGround(24, 30, 17);
createGround(34, 40, 17);
createGround(44, 50, 17);
createGround(54, 60, 17);
createGround(64, 74, 17);
createGround(76, 78, 17);
createHole(13, 3);
createHole(21, 3);
createHole(31, 3);
createHole(41, 3);
createHole(51, 3);
createHole(61, 3);
createHole(75, 2);
createBrick(6, 7, 16);
createBrick(18, 19, 16);
createBrick(27, 28, 16);
createBrick(37, 38, 16);
createBrick(47, 48, 16);
createBrick(57, 58, 16);
createBrick(68, 69, 16);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(5, 16, 1);
addPowerUp(12, 16, 2);
addPowerUp(20, 16, 1);
addPowerUp(28, 16, 2);
addPowerUp(36, 16, 1);
addPowerUp(44, 16, 2);
addPowerUp(52, 16, 1);
addPowerUp(60, 16, 2);
addPowerUp(68, 16, 1);
addPowerUp(74, 16, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡2：山地
// ============================================================
void loadLevel2() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 6, 17);
createGround(9, 11, 16);
createGround(14, 16, 15);
createGround(19, 21, 16);
createGround(24, 26, 17);
createGround(29, 31, 16);
createGround(34, 36, 15);
createGround(39, 41, 16);
createGround(44, 46, 17);
createGround(49, 51, 16);
createGround(54, 56, 15);
createGround(59, 61, 16);
createGround(64, 66, 17);
createGround(69, 74, 17);
createGround(76, 78, 17);
createHole(6, 3);
createHole(11, 3);
createHole(16, 3);
createHole(21, 3);
createHole(26, 3);
createHole(31, 3);
createHole(36, 3);
createHole(41, 3);
createHole(46, 3);
createHole(51, 3);
createHole(56, 3);
createHole(61, 3);
createHole(66, 3);
createHole(75, 2);
createBrick(4, 5, 16);
createBrick(14, 15, 14);
createBrick(24, 25, 16);
createBrick(34, 35, 14);
createBrick(44, 45, 16);
createBrick(54, 55, 14);
createBrick(64, 65, 16);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(5, 16, 1);
addPowerUp(14, 14, 2);
addPowerUp(24, 16, 1);
addPowerUp(34, 14, 2);
addPowerUp(44, 16, 1);
addPowerUp(54, 14, 2);
addPowerUp(64, 16, 1);
addPowerUp(74, 16, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡3：城堡
// ============================================================
void loadLevel3() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 78, 17);
createBrick(8, 12, 16);
createBrick(8, 12, 13);
createBrick(8, 10, 10);
createBrick(18, 22, 16);
createBrick(18, 22, 13);
createBrick(20, 22, 10);
createBrick(28, 32, 16);
createBrick(28, 32, 13);
createBrick(28, 30, 10);
createBrick(38, 42, 16);
createBrick(38, 42, 13);
createBrick(40, 42, 10);
createBrick(48, 52, 16);
createBrick(48, 52, 13);
createBrick(48, 50, 10);
createBrick(58, 62, 16);
createBrick(58, 62, 13);
createBrick(60, 62, 10);
createBrick(68, 72, 16);
createBrick(68, 72, 13);
createBrick(68, 70, 10);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(10, 15, 1);
addPowerUp(10, 12, 2);
addPowerUp(20, 15, 1);
addPowerUp(20, 12, 2);
addPowerUp(30, 15, 1);
addPowerUp(30, 12, 2);
addPowerUp(40, 15, 1);
addPowerUp(40, 12, 2);
addPowerUp(50, 15, 1);
addPowerUp(50, 12, 2);
addPowerUp(60, 15, 1);
addPowerUp(60, 12, 2);
addPowerUp(70, 15, 1);
addPowerUp(70, 12, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡4：沙漠
// ============================================================
void loadLevel4() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 5, 17);
createGround(8, 10, 17);
createGround(13, 15, 17);
createGround(18, 20, 17);
createGround(23, 25, 17);
createGround(28, 30, 17);
createGround(33, 35, 17);
createGround(38, 40, 17);
createGround(43, 45, 17);
createGround(48, 50, 17);
createGround(53, 55, 17);
createGround(58, 60, 17);
createGround(63, 65, 17);
createGround(68, 70, 17);
createGround(73, 74, 17);
createGround(76, 78, 17);
createHole(5, 3);
createHole(10, 3);
createHole(15, 3);
createHole(20, 3);
createHole(25, 3);
createHole(30, 3);
createHole(35, 3);
createHole(40, 3);
createHole(45, 3);
createHole(50, 3);
createHole(55, 3);
createHole(60, 3);
createHole(65, 3);
createHole(70, 3);
createHole(75, 2);
createBrick(3, 4, 16);
createBrick(13, 14, 16);
createBrick(23, 24, 16);
createBrick(33, 34, 16);
createBrick(43, 44, 16);
createBrick(53, 54, 16);
createBrick(63, 64, 16);
createBrick(73, 74, 16);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(8, 16, 1);
addPowerUp(18, 16, 2);
addPowerUp(28, 16, 1);
addPowerUp(38, 16, 2);
addPowerUp(48, 16, 1);
addPowerUp(58, 16, 2);
addPowerUp(68, 16, 1);
addPowerUp(74, 16, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡5：森林
// ============================================================
void loadLevel5() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 78, 17);
createBrick(4, 6, 16);
createBrick(4, 6, 13);
createBrick(4, 4, 10);
createBrick(10, 12, 16);
createBrick(10, 12, 13);
createBrick(16, 18, 16);
createBrick(16, 18, 13);
createBrick(16, 16, 10);
createBrick(22, 24, 16);
createBrick(22, 24, 13);
createBrick(28, 30, 16);
createBrick(28, 30, 13);
createBrick(28, 28, 10);
createBrick(34, 36, 16);
createBrick(34, 36, 13);
createBrick(40, 42, 16);
createBrick(40, 42, 13);
createBrick(40, 40, 10);
createBrick(46, 48, 16);
createBrick(46, 48, 13);
createBrick(52, 54, 16);
createBrick(52, 54, 13);
createBrick(52, 52, 10);
createBrick(58, 60, 16);
createBrick(58, 60, 13);
createBrick(64, 66, 16);
createBrick(64, 66, 13);
createBrick(64, 64, 10);
createBrick(70, 72, 16);
createBrick(70, 72, 13);
createHole(7, 2);
createHole(19, 2);
createHole(31, 2);
createHole(43, 2);
createHole(55, 2);
createHole(67, 2);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(5, 15, 1);
addPowerUp(11, 15, 2);
addPowerUp(17, 15, 1);
addPowerUp(23, 15, 2);
addPowerUp(29, 15, 1);
addPowerUp(35, 15, 2);
addPowerUp(41, 15, 1);
addPowerUp(47, 15, 2);
addPowerUp(53, 15, 1);
addPowerUp(59, 15, 2);
addPowerUp(65, 15, 1);
addPowerUp(71, 15, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡6：冰原
// ============================================================
void loadLevel6() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 4, 17);
createGround(7, 9, 17);
createGround(12, 14, 17);
createGround(17, 19, 17);
createGround(22, 24, 17);
createGround(27, 29, 17);
createGround(32, 34, 17);
createGround(37, 39, 17);
createGround(42, 44, 17);
createGround(47, 49, 17);
createGround(52, 54, 17);
createGround(57, 59, 17);
createGround(62, 64, 17);
createGround(67, 69, 17);
createGround(72, 74, 17);
createGround(76, 78, 17);
createHole(4, 3);
createHole(9, 3);
createHole(14, 3);
createHole(19, 3);
createHole(24, 3);
createHole(29, 3);
createHole(34, 3);
createHole(39, 3);
createHole(44, 3);
createHole(49, 3);
createHole(54, 3);
createHole(59, 3);
createHole(64, 3);
createHole(69, 3);
createHole(75, 2);
createBrick(2, 3, 16);
createBrick(12, 13, 16);
createBrick(22, 23, 16);
createBrick(32, 33, 16);
createBrick(42, 43, 16);
createBrick(52, 53, 16);
createBrick(62, 63, 16);
createBrick(72, 73, 16);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
addPowerUp(7, 16, 1);
addPowerUp(17, 16, 2);
addPowerUp(27, 16, 1);
addPowerUp(37, 16, 2);
addPowerUp(47, 16, 1);
addPowerUp(57, 16, 2);
addPowerUp(67, 16, 1);
addPowerUp(74, 16, 2);
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡7：火山
// ============================================================
void loadLevel7() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 5, 17);
createGround(8, 10, 16);
createGround(13, 15, 15);
createGround(18, 20, 16);
createGround(23, 25, 17);
createGround(28, 30, 16);
createGround(33, 35, 15);
createGround(38, 40, 16);
createGround(43, 45, 17);
createGround(48, 50, 16);
createGround(53, 55, 15);
createGround(58, 60, 16);
createGround(63, 65, 17);
createGround(68, 70, 16);
createGround(73, 74, 17);
createGround(76, 78, 17);
createHole(5, 3);
createHole(10, 3);
createHole(15, 3);
createHole(20, 3);
createHole(25, 3);
createHole(30, 3);
createHole(35, 3);
createHole(40, 3);
createHole(45, 3);
createHole(50, 3);
createHole(55, 3);
createHole(60, 3);
createHole(65, 3);
createHole(70, 3);
createHole(75, 2);
createBrick(3, 4, 16);
createBrick(3, 4, 13);
createBrick(13, 14, 14);
createBrick(13, 14, 11);
createBrick(23, 24, 16);
createBrick(23, 24, 13);
createBrick(33, 34, 14);
createBrick(33, 34, 11);
createBrick(43, 44, 16);
createBrick(43, 44, 13);
createBrick(53, 54, 14);
createBrick(53, 54, 11);
createBrick(63, 64, 16);
createBrick(63, 64, 13);
createBrick(73, 74, 16);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
for (int i = 0; i < 8; i++) {
int x = 8 + i * 9;
addPowerUp(x, 16 - (i % 3), (i % 2 == 0) ? 1 : 2);
}
cameraX = 0;
generateClouds();
}
// ============================================================
// 关卡8：最终关
// ============================================================
void loadLevel8() {
tiles.clear();
powerUps.clear();
levelComplete = false;
finishX = 75;
createGround(1, 78, 17);
createBrick(4, 8, 16);
createBrick(4, 8, 13);
createBrick(4, 6, 10);
createBrick(4, 4, 7);
createBrick(12, 16, 16);
createBrick(12, 16, 13);
createBrick(20, 24, 16);
createBrick(20, 24, 13);
createBrick(22, 24, 10);
createBrick(28, 32, 16);
createBrick(28, 32, 13);
createBrick(36, 40, 16);
createBrick(36, 40, 13);
createBrick(38, 40, 10);
createBrick(44, 48, 16);
createBrick(44, 48, 13);
createBrick(52, 56, 16);
createBrick(52, 56, 13);
createBrick(54, 56, 10);
createBrick(60, 64, 16);
createBrick(60, 64, 13);
createBrick(68, 72, 16);
createBrick(68, 72, 13);
createBrick(70, 72, 10);
createHole(9, 3);
createHole(17, 3);
createHole(25, 3);
createHole(33, 3);
createHole(41, 3);
createHole(49, 3);
createHole(57, 3);
createHole(65, 3);
createHole(74, 2);
createFinish(75, 16);
int spawnX = 3;
playerX = spawnX;
playerY = 16;
respawnX = spawnX;
respawnY = 16;
for (int i = 0; i < 10; i++) {
int x = 6 + i * 7;
addPowerUp(x, 16 - (i % 4), (i % 2 == 0) ? 1 : 2);
}
cameraX = 0;
generateClouds();
}
void loadLevel(int level) {
if (level == 0) loadLevel1();
else if (level == 1) loadLevel2();
else if (level == 2) loadLevel3();
else if (level == 3) loadLevel4();
else if (level == 4) loadLevel5();
else if (level == 5) loadLevel6();
else if (level == 6) loadLevel7();
else loadLevel8();
currentLevel = level;
stuckCounter = 0;
lastPlayerX = playerX;
lastPlayerY = playerY;
}
bool reachedFinish() {
for (int i = 0; i < (int)tiles.size(); i++) {
if (tiles[i].type == 3) {
if ((tiles[i].x == playerX || tiles[i].x == playerX + 1) && tiles[i].y == playerY) {
return true;
}
}
}
return false;
}
void playerTakeDamage() {
if (!isInvincible && lives > 0) {
lives--;
isInvincible = true;
invincibleTimer = INVINCIBLE_DURATION;
system("color 0C");
Sleep(20);
system("color 0A");
if (lives <= 0) {
gameOver = true;
}
}
}
// ============================================================
// 渲染到缓冲区
// ============================================================
void renderToBuffer() {
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
screenBuffer[y][x] = ' ';
}
}
int newCameraX = playerX - WIDTH / 2;
if (newCameraX < 0) newCameraX = 0;
if (newCameraX > MAP_WIDTH - WIDTH) newCameraX = MAP_WIDTH - WIDTH;
cameraX = newCameraX;
// 云朵
for (int i = 0; i < (int)clouds.size(); i++) {
int screenX = clouds[i].x - cameraX / 3;
if (screenX < -10) screenX += MAP_WIDTH;
if (screenX > WIDTH + 10) screenX -= MAP_WIDTH;
if (screenX >= 0 && screenX < WIDTH && clouds[i].y >= 0 && clouds[i].y < HEIGHT) {
for (int j = -clouds[i].size/2; j <= clouds[i].size/2; j++) {
int px = screenX + j;
if (px >= 0 && px < WIDTH) {
if (abs(j) % 2 == 0) {
screenBuffer[clouds[i].y][px] = '.';
} else {
screenBuffer[clouds[i].y][px] = '~';
}
if (clouds[i].y + 1 < HEIGHT) {
screenBuffer[clouds[i].y + 1][px] = '.';
}
}
}
}
}
// 地形
for (int i = 0; i < (int)tiles.size(); i++) {
int worldX = tiles[i].x;
int worldY = tiles[i].y;
int screenX = worldX - cameraX;
if (screenX >= 0 && screenX < WIDTH && worldY >= 0 && worldY < HEIGHT) {
if (tiles[i].type == 1) screenBuffer[worldY][screenX] = '=';
else if (tiles[i].type == 2) screenBuffer[worldY][screenX] = '#';
else if (tiles[i].type == 3) {
screenBuffer[worldY][screenX] = (frameCount % 20 < 10) ? 'F' : '|';
if (worldY > 0) screenBuffer[worldY-1][screenX] = '^';
}
}
}
// 道具
for (int i = 0; i < (int)powerUps.size(); i++) {
if (powerUps[i].active) {
int worldX = powerUps[i].x;
int worldY = powerUps[i].y;
int screenX = worldX - cameraX;
if (screenX >= 0 && screenX < WIDTH && worldY >= 0 && worldY < HEIGHT) {
screenBuffer[worldY][screenX] = (powerUps[i].type == 1) ? 'H' : '*';
}
}
}
// 玩家
int screenX = playerX - cameraX;
if (screenX >= 0 && screenX < WIDTH && playerY >= 0 && playerY < HEIGHT) {
if (!(isInvincible && (flashCounter % 10 < 5))) {
screenBuffer[playerY][screenX] = 'M';
}
}
}
void refreshScreen() {
gotoxy(0, 0);
cout << "####################################################\n";
for (int y = 0; y < HEIGHT; y++) {
cout << "#";
for (int x = 0; x < WIDTH; x++) {
cout << screenBuffer[y][x];
}
cout << "#\n";
}
cout << "####################################################\n";
// 关卡名（中文）
char levelNames[8][10] = {"草原", "山地", "城堡", "沙漠", "森林", "冰原", "火山", "最终"};
cout << "得分:" << score << " 关卡:" << (currentLevel+1) << "/" << TOTAL_LEVELS
<< " " << levelNames[currentLevel] << " 生命:";
for (int i = 0; i < lives; i++) cout << "[H]";
for (int i = lives; i < MAX_LIVES; i++) cout << "[ ]";
if (isInvincible) cout << " [无敌]";
cout << " H=加命 *=加分 WASD移动 空格跳跃 Q退出 R脱离\n";
// 进度条
int progress = (playerX * 50) / MAP_WIDTH;
cout << "[";
for (int i = 0; i < 50; i++) {
if (i < progress) cout << "=";
else if (i == progress) cout << ">";
else cout << " ";
}
cout << "] " << (progress * 2) << "%\n";
}
void update() {
frameCount++;
flashCounter++;
if (isInvincible) {
invincibleTimer--;
if (invincibleTimer <= 0) isInvincible = false;
}
if (isPlayerStuck()) {
forceUnstuck();
stuckCounter = 0;
} else {
if (playerX == lastPlayerX && playerY == lastPlayerY) {
stuckCounter++;
if (stuckCounter > STUCK_THRESHOLD) {
if (!isSolid(playerX + 1, playerY) && playerX + 1 < MAP_WIDTH - 1) {
playerX++;
} else if (!isSolid(playerX - 1, playerY) && playerX - 1 > 0) {
playerX--;
} else {
forceUnstuck();
}
stuckCounter = 0;
}
} else {
stuckCounter = 0;
lastPlayerX = playerX;
lastPlayerY = playerY;
}
}
if (reachedFinish() && !levelComplete) {
levelComplete = true;
score += 100;
system("color 0E");
Sleep(40);
system("color 0D");
Sleep(40);
system("color 0A");
if (currentLevel < TOTAL_LEVELS - 1) {
loadLevel(currentLevel + 1);
} else {
gameOver = true;
}
return;
}
// 跳跃物理
if (isJumping) {
if (jumpVelocity > 0) {
if (!isSolid(playerX, playerY - 1)) {
playerY--;
} else {
jumpVelocity = 0;
}
jumpVelocity--;
} else {
if (!isSolid(playerX, playerY + 1)) {
playerY++;
if (jumpVelocity < 0) {
jumpVelocity--;
}
} else {
isJumping = false;
jumpVelocity = 0;
}
}
} else {
if (!isSolid(playerX, playerY + 1)) {
playerY++;
if (playerY >= HEIGHT) {
playerTakeDamage();
if (lives > 0) {
playerX = respawnX;
playerY = respawnY;
}
}
}
}
// 道具碰撞
for (int i = 0; i < (int)powerUps.size(); i++) {
if (!powerUps[i].active) continue;
if (playerX == powerUps[i].x && playerY == powerUps[i].y) {
if (powerUps[i].type == 1) {
if (lives < MAX_LIVES) {
lives++;
score += 30;
system("color 0D");
Sleep(20);
system("color 0A");
}
} else if (powerUps[i].type == 2) {
score += 50;
system("color 0E");
Sleep(20);
system("color 0A");
}
powerUps.erase(powerUps.begin() + i);
i--;
}
}
}
void input() {
if (_kbhit()) {
char key = _getch();
if (key == 224) {
key = _getch();
if (key == 72) {
if (!isJumping && isSolid(playerX, playerY + 1)) {
isJumping = true;
jumpVelocity = MAX_JUMP;
}
}
else if (key == 75) {
if (playerX > 0 && !isSolid(playerX - 1, playerY)) {
playerX--;
}
}
else if (key == 77) {
if (playerX < MAP_WIDTH - 1 && !isSolid(playerX + 1, playerY)) {
playerX++;
}
}
}
else {
if (key == 'q' || key == 'Q') {
gameOver = true;
return;
}
if (key == 'r' || key == 'R') {
forceUnstuck();
return;
}
if (key == 'w' || key == 'W' || key == ' ') {
if (!isJumping && isSolid(playerX, playerY + 1)) {
isJumping = true;
jumpVelocity = MAX_JUMP;
}
}
if (key == 'a' || key == 'A') {
if (playerX > 0 && !isSolid(playerX - 1, playerY)) {
playerX--;
}
}
if (key == 'd' || key == 'D') {
if (playerX < MAP_WIDTH - 1 && !isSolid(playerX + 1, playerY)) {
playerX++;
}
}
}
}
}
void showGameOver() {
system("cls");
cout << "========================================\n";
cout << " \n";
if (lives <= 0) {
cout << " 游 戏 结 束 ！ \n";
} else if (currentLevel >= TOTAL_LEVELS - 1 && levelComplete) {
cout << " ???? 恭喜通关全部8关！ ???? \n";
cout << " 你真是跳跃大师！ \n";
} else {
cout << " 游 戏 结 束 ！ \n";
}
cout << " \n";
cout << " 最终得分: " << score << "\n";
cout << " 剩余生命: ";
for (int i = 0; i < lives; i++) cout << "[H]";
cout << "\n";
cout << " 到达关卡: " << (currentLevel + 1) << "/" << TOTAL_LEVELS << "\n";
cout << " \n";
cout << "========================================\n";
system("pause");
}
int main() {
setConsoleFast();
hideCursor();
system("color 0A");
srand((unsigned)time(0));
system("cls");
cout << "========================================\n";
cout << " 超 级 马 里 奥 \n";
cout << "========================================\n";
cout << " 兼容 Dev-C++ 5.11 及所有版本！ \n";
cout << " 操作：WASD移动 空格跳跃 \n";
cout << " Q退出 R脱离卡死 \n";
cout << " 目标：到达终点旗帜过关！ \n";
cout << " 共8关，祝你顺利！ \n";
cout << "========================================\n";
cout << "\n按任意键开始..." << endl;
_getch();
loadLevel(0);
while (!gameOver) {
renderToBuffer();
refreshScreen();
input();
update();
Sleep(16);
}
showGameOver();
return 0;
}
这里空空如也
有帮助，赞一个