迷宫1
yi_hr
·
·
个人记录
#define _WIN32_WINNT 0x0600 // This defines the minimum Windows version for API availability (0x0600 for Windows Vista)
#include <bits/stdc++.h>
#include <windows.h> // For Windows specific console functions and GetAsyncKeyState, PlaySound
#include <cmath>
#include <fstream> // For file input/output (map loading)
#include <functional> // For std::function (in generateChunk)
#include <random> // For std::mt19937 (in generateChunk)
// For PlaySound - remember to link with winmm.lib (in Visual Studio: Project -> Properties -> Linker -> Input -> Additional Dependencies, add winmm.lib)
// Or compile with: g++ your_game.cpp -o your_game -lwinmm
using namespace std;
// --- Constants and Enums ---
// Console size set by user
static int SCREEN_WIDTH;
static int SCREEN_HEIGHT;
static CHAR_INFO* screen = nullptr;
static HANDLE hConsole;
static SMALL_RECT writeRegion;
static COORD bufCoord = {0,0};
const double PI = 3.141592653589793;
// Game related constants
constexpr int CHUNK_SIZE = 20; // Size of each maze chunk
const double PLAYER_HEIGHT = 0.5; // Player's height from the floor (0 is floor level)
const double GRAVITY = 0.08; // Acceleration due to gravity
const double JUMP_FORCE = 0.2; // Initial upward velocity for jump
const double MOVE_SPEED = 0.1; // Player movement speed
const double MOUSE_SENSITIVITY = 0.003; // Mouse camera sensitivity
const double KEY_SENSITIVITY = 0.05; // Keyboard camera sensitivity
const double PITCH_SENSITIVITY = 0.03; // Keyboard pitch sensitivity
const double MAX_PITCH_ANGLE = PI / 2.0 - 0.1; // Limit pitch to prevent flipping
// Block types (using enum for better readability)
enum BlockType {
EMPTY = 0,
WALL = 1,
TREASURE = 2,
EXIT = 3,
MONSTER = 4, // New: Simple monster block
TRAP = 5 // New: Simple trap block
};
// Console Colors (Standard Windows Console Colors)
enum ConsoleColor {
BLACK = 0,
DARK_BLUE = 1,
DARK_GREEN = 2,
DARK_CYAN = 3,
DARK_RED = 4,
DARK_MAGENTA = 5,
DARK_YELLOW = 6,
GREY = 7,
DARK_GREY = 8,
BLUE = 9,
GREEN = 10,
CYAN = 11,
RED = 12,
MAGENTA = 13,
YELLOW = 14,
WHITE = 15
};
struct Chunk {
int map[CHUNK_SIZE][CHUNK_SIZE];
};
using ChunkCoord = pair<int,int>;
// Fast hash pair for unordered_map
struct pair_hash {
size_t operator()(const ChunkCoord& p) const {
return std::hash<int>()(p.first) ^ (std::hash<int>()(p.second)<<1);
}
};
unordered_map<ChunkCoord,Chunk,pair_hash> chunkPool;
// Get chunk coordinates and local offset within chunk
inline ChunkCoord getChunkPos(int x, int y) {
int cx = (x >= 0) ? (x/CHUNK_SIZE) : ((x+1-CHUNK_SIZE)/CHUNK_SIZE);
int cy = (y >= 0) ? (y/CHUNK_SIZE) : ((y+1-CHUNK_SIZE)/CHUNK_SIZE);
return ChunkCoord(cx, cy);
}
inline void getLocalPos(int x, int y, int& lx, int& ly) {
lx = x % CHUNK_SIZE; if(lx<0) lx+=CHUNK_SIZE;
ly = y % CHUNK_SIZE; if(ly<0) ly+=CHUNK_SIZE;
}
// Player and Particle struct
struct Particle { double x,y,z,vx,vy,vz; int life; char symbol; WORD color; };
struct Player {
double x=1.5,y=1.5,z=PLAYER_HEIGHT,angle=0,pitch=0,vz=0;
bool onGround=true;
int health=100, treasures=0;
double cosA,sinA,cosP,sinP; // Cos/Sin of angle (yaw) and pitch
inline void updateTrig(){ cosA=cos(angle); sinA=sin(angle); cosP=cos(pitch); sinP=sin(pitch); }
} player;
static vector<Particle> particles;
// --- New: Monster Structure and List ---
struct Monster {
double x, y; // Precise float coordinates (center of the tile)
double moveCooldown; // Timer for movement
int id; // For unique identification, if needed
};
static vector<Monster> monsters; // Global list of active monsters
// Monster constants
const double MONSTER_MOVE_DELAY = 0.5; // Monster moves every 0.5 seconds
const double MONSTER_DETECTION_RANGE = 40.0; // Monsters detect player within 40 units (Euclidean distance)
static BlockType selectedBlockType = WALL; // New: Variable to hold currently selected block type for placing
// Particle constants
const double PARTICLE_GRAVITY = 0.08;
const double PARTICLE_FRICTION = 0.98;
bool showMiniMap=false, mouseMode=false;
bool backroomsMode=false; // Backrooms mode switch
POINT lastMousePos;
bool gameOver = false; // Game over flag
long long startTime; // For game timer
int gameEndReason = 0; // 0: manual exit, 1: win, 2: lose
// === NEW: Damage Flash Variables ===
static double damageFlashTimer = 0.0; // Remaining flash screen time (seconds)
const double DAMAGE_FLASH_DURATION = 0.2; // Total flash duration (seconds)
// ===================================
// Map mode declaration
enum class MapMode { Infinite, Existing };
static MapMode mapMode = MapMode::Infinite; // Default to infinite
// Map access wrapper (forward declaration for use in tryMoveMonster)
int getWorldAt(int x, int y);
void setWorldAt(int x, int y, int value);
void playSound(const char* filename); // Forward declaration
// --- New: Minimap scaling variables ---
static int minimap_radius = 7; // Default to show 7 tiles in each direction (15x15 total)
const int MIN_MINIMAP_RADIUS = 3; // Smallest minimap (7x7 total)
const int MAX_MINIMAP_RADIUS = 200; // Largest minimap (41x41 total)
// --- END NEW ---
// --- NEW: Minimap Flip Variable ---
static bool minimap_flipped = false; // False = normal, True = flipped horizontally
// --- END NEW ---
// --- New: Helper function for monster movement and digging ---
// Returns true if the monster successfully moved (or dug to move)
bool tryMoveMonster(Monster& m, int old_mx, int old_my, int new_mx, int new_my) {
// Check if the target block is occupied by *another* monster
for (const auto& other_m : monsters) {
if (&other_m == &m) continue; // Skip self
if (static_cast<int>(other_m.x) == new_mx && static_cast<int>(other_m.y) == new_my) { // Monster x/y are center, new_mx/my are floor
return false; // Target cell occupied by another monster, cannot move here
}
}
int target_block_type = getWorldAt(new_mx, new_my);
if (target_block_type == WALL || target_block_type == TREASURE || target_block_type == EXIT || target_block_type == TRAP) {
// It's an obstacle, monster will dig.
// Dig 3x3 area around the target (new_mx, new_my)
for (int dy_dig = -1; dy_dig <= 1; ++dy_dig) {
for (int dx_dig = -1; dx_dig <= 1; ++dx_dig) {
int dig_x = new_mx + dx_dig;
int dig_y = new_my + dy_dig;
// Only clear non-empty blocks.
// Important: When a monster digs, it should not dig other monsters from map.
if (getWorldAt(dig_x, dig_y) != EMPTY && getWorldAt(dig_x, dig_y) != MONSTER) {
setWorldAt(dig_x, dig_y, EMPTY);
}
}
}
// After digging, the target tile (new_mx, new_my) is now empty (or was already, if digging around it).
// So, the monster can now move there.
setWorldAt(old_mx, old_my, EMPTY); // Clear monster's old map spot
m.x = new_mx + 0.5; // Update monster's precise position to center of new tile
m.y = new_my + 0.5;
setWorldAt(static_cast<int>(m.x),static_cast<int>(m.y), MONSTER); // Set monster's new map spot
// playSound("dig.wav"); // Monster digging sound
return true;
} else if (target_block_type == EMPTY) {
// It's an empty space, just move.
setWorldAt(old_mx, old_my, EMPTY); // Clear monster's old map spot
m.x = new_mx + 0.5; // Update monster's precise position
m.y = new_my + 0.5;
setWorldAt(static_cast<int>(m.x),static_cast<int>(m.y), MONSTER); // Set monster's new map spot
return true;
}
return false; // Cannot move to this type of block (e.g., player occupies it, or other unhandled types)
}
// --- End New Helper Function ---
// Ensure connectivity between chunks during maze generation
void generateChunk(const ChunkCoord& coord) {
Chunk& chunk = chunkPool[coord];
// Fill with walls
for(int y=0; y<CHUNK_SIZE; ++y)
for(int x=0; x<CHUNK_SIZE; ++x)
chunk.map[y][x] = WALL;
// Random engine, seeded by chunk coordinates for consistent generation
uint64_t seed = coord.first * 73856093ull ^ coord.second * 19349663ull;
mt19937 rng(seed);
// DFS for maze path generation (single odd-point grid, not digging outer boundary)
function<void(int,int)> dfs = [&](int x,int y){
chunk.map[y][x] = EMPTY;
// Shuffle directions
vector<int> dir = {0,1,2,3};
shuffle(dir.begin(), dir.end(), rng);
static const int dx[] = {1,-1,0,0}, dy[] = {0,0,1,-1};
for(int d:dir) {
int nx = x + dx[d]*2, ny = y + dy[d]*2;
if(nx > 0 && nx < CHUNK_SIZE-1 && ny > 0 && ny < CHUNK_SIZE-1 && chunk.map[ny][nx] == WALL) {
chunk.map[y+dy[d]][x+dx[d]] = EMPTY; // Dig path
dfs(nx, ny);
}
}
};
dfs(1, 1); // Start DFS from (1,1)
// Place dynamic elements (Treasures, Exits, Monsters, Traps)
auto place_element = [&](int type, int chance_inv, int min_dist_border) {
if (rng() % chance_inv == 0) {
int tx = rng() % (CHUNK_SIZE - 2 * min_dist_border) + min_dist_border;
int ty = rng() % (CHUNK_SIZE - 2 * min_dist_border) + min_dist_border;
// Only place if it's an empty spot and not too close to player spawn (1.5, 1.5)
// Or if type is Monster, avoid spawning too close to player initially
if (chunk.map[ty][tx] == EMPTY) {
// Approximate distance check from player spawn (0,0 chunk, 1.5, 1.5)
int world_x = coord.first * CHUNK_SIZE + tx;
int world_y = coord.second * CHUNK_SIZE + ty;
if (type == MONSTER && sqrt(pow(world_x - player.x, 2) + pow(world_y - player.y, 2)) < MONSTER_DETECTION_RANGE + 5) {
return; // Avoid spawning monsters too close to player at start
}
chunk.map[ty][tx] = type;
// --- New: If it's a monster, add it to the global monsters list ---
if (type == MONSTER) {
monsters.push_back({
(double)coord.first * CHUNK_SIZE + tx + 0.5, // Center monster in tile
(double)coord.second * CHUNK_SIZE + ty + 0.5,
MONSTER_MOVE_DELAY, // Initial cooldown
(int)monsters.size() // Simple ID
});
}
// --- End New ---
}
}
};
place_element(TREASURE, 10, 2); // 1/10 chance, min 2 units from border
place_element(EXIT, 30, 3); // 1/30 chance, min 3 units from border
place_element(MONSTER, 40, 2); // 1/40 chance, min 2 units from border
place_element(TRAP, 25, 2); // 1/25 chance, min 2 units from border
// Ensure connectivity with neighboring chunks
// Left side: If left neighbor exists and has a path on its right, open path here
ChunkCoord leftC = {coord.first - 1, coord.second};
if (chunkPool.count(leftC)) {
Chunk& lc = chunkPool[leftC];
for (int y = 3; y < CHUNK_SIZE - 3; y += 2) { // Iterate over potential path points
if (lc.map[y][CHUNK_SIZE - 2] == EMPTY) { // If left chunk's right edge path is open
chunk.map[y][0] = EMPTY; // Open this chunk's left edge
chunk.map[y][1] = EMPTY; // And the next cell into the chunk
}
}
}
// Top side: Same for top neighbor
ChunkCoord upC = {coord.first, coord.second - 1};
if (chunkPool.count(upC)) {
Chunk& uc = chunkPool[upC];
for (int x = 3; x < CHUNK_SIZE - 3; x += 2) {
if (uc.map[CHUNK_SIZE - 2][x] == EMPTY) {
chunk.map[0][x] = EMPTY;
chunk.map[1][x] = EMPTY;
}
}
}
// Open paths to the right/bottom: These points will be considered by future neighboring chunks
for (int y = 3; y < CHUNK_SIZE - 3; y += 2) {
if (chunk.map[y][CHUNK_SIZE - 3] == EMPTY) { // If internal path reaches third-to-last column on right
chunk.map[y][CHUNK_SIZE - 2] = EMPTY; // Open up to second-to-last column
}
}
for (int x = 3; x < CHUNK_SIZE - 3; x += 2) {
if (chunk.map[CHUNK_SIZE - 3][x] == EMPTY) { // If internal path reaches third-to-last row on bottom
chunk.map[CHUNK_SIZE - 2][x] = EMPTY; // Open up to second-to-last row
}
}
}
// Map access wrapper
int getWorldAt(int x, int y) {
ChunkCoord c = getChunkPos(x, y);
int lx, ly;
getLocalPos(x, y, lx, ly);
if (chunkPool.count(c)) {
return chunkPool[c].map[ly][lx];
} else {
if (mapMode == MapMode::Infinite) {
// If chunk doesn't exist and in infinite mode, generate it
generateChunk(c);
return chunkPool[c].map[ly][lx]; // Return the newly generated block type
} else { // MapMode::Existing
// If in existing map mode and chunk not loaded, it's outside the defined map. Treat as wall.
return WALL;
}
}
}
// Set world block type
void setWorldAt(int x, int y, int value) {
ChunkCoord c = getChunkPos(x, y);
int lx, ly;
getLocalPos(x, y, lx, ly);
// Only modify if the chunk exists in the pool (either pre-loaded or already generated)
// In Existing mode, this prevents creating new chunks outside the loaded map.
// In Infinite mode, getWorldAt would usually generate the chunk before setWorldAt is called for new areas.
if(chunkPool.count(c)) {
chunkPool[c].map[ly][lx] = value;
}
}
// Load existing map from file
void loadExistingMap(const string& filename) {
ifstream fin(filename);
if (!fin) {
cerr << "错误：无法打开地图文件: " << filename << endl;
mapMode = MapMode::Infinite; // Fallback to infinite generation
cout << "已切换到无限自动生成模式。\n";
return;
}
// Clear existing dynamic elements from previous runs/infinite mode
chunkPool.clear();
monsters.clear();
int chunkX, chunkY;
int loaded_chunks = 0;
while (fin >> chunkX >> chunkY) {
ChunkCoord coord = {chunkX, chunkY};
Chunk c;
for (int y = 0; y < CHUNK_SIZE; ++y) {
for (int x = 0; x < CHUNK_SIZE; ++x) {
int v_int;
if (!(fin >> v_int)) {
cerr << "错误：地图文件格式不正确，在读取区块 (" << chunkX << "," << chunkY << ") 的块数据时出错。\n";
fin.close();
mapMode = MapMode::Infinite; // Fallback
cout << "已切换到无限自动生成模式。\n";
return;
}
BlockType v = static_cast<BlockType>(v_int);
c.map[y][x] = v_int; // Store the integer value directly
// If it's a monster, add to dynamic list
if (v == MONSTER) {
monsters.push_back({
(double)coord.first * CHUNK_SIZE + x + 0.5, // Center monster in tile
(double)coord.second * CHUNK_SIZE + y + 0.5,
MONSTER_MOVE_DELAY, // Initial cooldown
(int)monsters.size() // Simple ID
});
}
}
}
chunkPool[coord] = c;
loaded_chunks++;
}
fin.close();
cout << "已加载 " << loaded_chunks << " 个区块。\n";
// MODIFICATION START: Set player position to the first available empty spot in any loaded chunk
bool found_spawn_location = false;
for (const auto& pair : chunkPool) {
ChunkCoord current_chunk_coord = pair.first;
const Chunk& current_chunk = pair.second;
int spawn_x_offset = current_chunk_coord.first * CHUNK_SIZE;
int spawn_y_offset = current_chunk_coord.second * CHUNK_SIZE;
for (int dy = 0; dy < CHUNK_SIZE; ++dy) {
for (int dx = 0; dx < CHUNK_SIZE; ++dx) {
if (current_chunk.map[dy][dx] == EMPTY) {
player.x = spawn_x_offset + dx + 0.5; // Center in the tile
player.y = spawn_y_offset + dy + 0.5;
found_spawn_location = true;
// Exit inner loops
goto end_spawn_search; // Use goto to break out of nested loops
}
}
}
}
end_spawn_search:; // Label for goto
if (!found_spawn_location) {
cout << "警告：在所有加载的区块中未找到空地作为玩家出生点，玩家可能出生在墙内。\n";
// Player will remain at initial {1.5, 1.5} if no empty spot found.
}
// MODIFICATION END
if (chunkPool.empty()) {
cout << "警告：没有加载任何区块，请检查地图文件。\n";
mapMode = MapMode::Infinite; // Fallback if no chunks loaded
cout << "已切换到无限自动生成模式。\n";
}
}
inline bool key(int vk){ return (GetAsyncKeyState(vk) & 0x8000) != 0; }
inline void draw(int x,int y,char c,WORD col){
if(y>=0&&y<SCREEN_HEIGHT&&x>=0&&x<SCREEN_WIDTH) {
CHAR_INFO cell_info;
cell_info.Char.AsciiChar = c;
cell_info.Attributes = col;
screen[y*SCREEN_WIDTH + x] = cell_info;
}
}
// Setup console and buffer
void initConsole(){
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
cout << "Enter console width height (e.g., 120 40): "; cin >> SCREEN_WIDTH >> SCREEN_HEIGHT;
COORD bufSize = {(SHORT)SCREEN_WIDTH,(SHORT)SCREEN_HEIGHT};
SetConsoleScreenBufferSize(hConsole,bufSize);
SMALL_RECT win={0,0,(SHORT)(SCREEN_WIDTH-1),(SHORT)(SCREEN_HEIGHT-1)};
SetConsoleWindowInfo(hConsole,TRUE,&win);
writeRegion=win;
screen = (CHAR_INFO*)malloc(sizeof(CHAR_INFO)*SCREEN_WIDTH*SCREEN_HEIGHT);
CONSOLE_CURSOR_INFO cci; GetConsoleCursorInfo(hConsole,&cci); cci.bVisible=false; SetConsoleCursorInfo(hConsole,&cci);
// Attempt to center mouse for initial setup
HWND hwnd=GetConsoleWindow(); RECT r; GetWindowRect(hwnd,&r);
int cx=(r.left+r.right)/2, cy=(r.top+r.bottom)/2;
SetCursorPos(cx,cy);
lastMousePos={cx,cy};
}
// Function to play a sound (blocking, for simple effects)
void playSound(const char* filename) {
// PlaySoundA(filename, NULL, SND_FILENAME | SND_ASYNC); // SND_ASYNC for non-blocking
// Commented out as sound files are not provided and cause linker errors without winmm.lib.
// Uncomment and link with winmm.lib if you have the WAV files.
}
// Fast render
void renderFrame(){
// precompute
double FOV=PI/3; // Field of View
double invW=1.0/SCREEN_WIDTH;
player.updateTrig();
// Adjust the "horizon" based on pitch and player's Z-position
int verticalOffset = int(player.pitch * (SCREEN_HEIGHT / PI / 2.0));
verticalOffset += int((player.z - PLAYER_HEIGHT) * SCREEN_HEIGHT); // Adjust based on player Z
int halfH_shifted = (SCREEN_HEIGHT>>1) + verticalOffset;
// Sky / Ceiling
WORD skyBaseColor = backroomsMode ? YELLOW : BLUE;
for(int y=0;y<halfH_shifted;y++){
for(int x=0;x<SCREEN_WIDTH;x++){
screen[y*SCREEN_WIDTH+x]={{' '},skyBaseColor};
// Backrooms mode: simulate ceiling lights
if(backroomsMode){
int light_grid_x = 5; // Horizontal grid count
int light_grid_y = 3; // Vertical grid count
int cell_width = SCREEN_WIDTH / light_grid_x;
int ceiling_height = max(1, halfH_shifted);
int cell_height = ceiling_height / light_grid_y;
if (cell_height == 0) cell_height = 1;
int current_cell_x_idx = x / cell_width;
int current_cell_y_idx = y / cell_height;
int light_center_x = current_cell_x_idx * cell_width + cell_width / 2;
int light_center_y = current_cell_y_idx * cell_height + cell_height / 2;
if(abs(x - light_center_x) < cell_width / 6 &&
abs(y - light_center_y) < cell_height / 6){
screen[y*SCREEN_WIDTH+x]={{' '},WHITE}; // White as light
}
}
}
}
// Raycast columns
for(int x=0;x<SCREEN_WIDTH;x++){
double camX=2*x*invW-1;
double rx=player.cosA - player.sinA*camX;
double ry=player.sinA + player.cosA*camX;
int mx=static_cast<int>(player.x), my=static_cast<int>(player.y);
double dDX=fabs(1/rx);
double dDY=fabs(1/ry);
double sDX=(rx<0?(player.x-mx)*dDX:(mx+1-player.x)*dDX);
double sDY=(ry<0?(player.y-my)*dDY:(my+1-player.y)*dDY);
int stepX=(rx<0?-1:1);
int stepY=(ry<0?-1:1);
int side;
int hitType=WALL; // Default to wall
// DDA algorithm
while(true){
if(sDX<sDY){sDX+=dDX; mx+=stepX; side=0;} else {sDY+=dDY; my+=stepY; side=1;}
hitType = getWorldAt(mx,my);
if(hitType) break; // Hit a wall or object
}
double perp = side? (my-player.y+(1-stepY)/2)/ry : (mx-player.x+(1-stepX)/2)/rx;
if(perp<0.05) perp=0.05;
// Calculate wall height based on distance and player's Z position
// The wall is assumed to be 1 unit high, from z=0 to z=1
int wall_top_y = int(halfH_shifted - (1.0 - player.z) * SCREEN_HEIGHT / perp);
int wall_bottom_y = int(halfH_shifted - (0.0 - player.z) * SCREEN_HEIGHT / perp);
// Adjust draw start and end Y-coordinates
int dS = max(0, wall_top_y);
int dE = min(SCREEN_HEIGHT, wall_bottom_y);
// Choose wall color based on backroomsMode and side
WORD baseCol;
if (backroomsMode) {
baseCol = YELLOW; // Backrooms: walls are yellow
} else {
baseCol = (side ? DARK_GREY : GREY); // Normal: Darker for side, lighter for front
}
for(int y=dS;y<dE;y++){
WORD col=baseCol;
char ch = ' ';
switch (hitType) {
case WALL: col = baseCol; ch = (perp<2.5?'#':(perp<5?'%':(perp<7.5?'*':'.'))); break;
case TREASURE: col = YELLOW | FOREGROUND_INTENSITY; ch = '$'; break; // Bright yellow for treasure
case EXIT: col = GREEN | FOREGROUND_INTENSITY; ch = 'E'; break; // Bright green for exit
case MONSTER: col = RED | FOREGROUND_INTENSITY; ch = 'M'; break; // Bright red for monster
case TRAP: col = DARK_RED | FOREGROUND_INTENSITY; ch = 'T'; break; // Dark red for trap
}
draw(x,y,ch,col);
}
// Floor and Ceiling (if player is below)
CHAR_INFO floor_char_info;
if (backroomsMode) {
floor_char_info = {{'.'}, YELLOW}; // Backrooms: floor is yellow
} else {
floor_char_info = {{'.'}, DARK_GREEN}; // Normal: floor is dark green
}
// Draw floor from wall bottom to screen bottom
for(int y=max(0, dE); y<SCREEN_HEIGHT; y++) {
screen[y*SCREEN_WIDTH+x]=floor_char_info;
}
// Draw ceiling above wall top (only if player is not at z=1.0 or higher, i.e., looking up at it)
for(int y=0; y<min(dS, halfH_shifted); y++) {
screen[y*SCREEN_WIDTH+x]={{' '},skyBaseColor};
}
}
// Particle rendering
for (const auto& p : particles) {
double px_rel = p.x - player.x;
double py_rel = p.y - player.y;
double pz_rel = p.z - player.z;
// Rotate relative coordinates based on player's yaw
double rotX = px_rel * player.cosA + py_rel * player.sinA;
double rotY_depth = py_rel * player.cosA - px_rel * player.sinA; // Depth before pitch
// Apply pitch rotation to vertical components
double final_pz = pz_rel * player.cosP - rotY_depth * player.sinP; // New effective Z after pitch
double final_depth = rotY_depth * player.cosP + pz_rel * player.sinP; // New effective depth after pitch
if (final_depth > 0.1) { // Particle is in front of player
double inv_depth = 1.0 / final_depth;
int screenX = int(SCREEN_WIDTH / 2 + rotX * SCREEN_HEIGHT * inv_depth);
int screenY = int(SCREEN_HEIGHT / 2 - final_pz * (SCREEN_HEIGHT/2) * inv_depth);
// Clamp screen coordinates
if (screenX >= 0 && screenX < SCREEN_WIDTH && screenY >= 0 && screenY < SCREEN_HEIGHT) {
draw(screenX, screenY, p.symbol, p.color);
}
}
}
// --- New: Monster rendering (similar to particle rendering) ---
for (const auto& m : monsters) {
double px_rel = m.x - player.x;
double py_rel = m.y - player.y;
double pz_rel = PLAYER_HEIGHT - player.z; // Assume monster is at player height (0.5 from floor)
// Rotate relative coordinates based on player's yaw
double rotX = px_rel * player.cosA + py_rel * player.sinA;
double rotY_depth = py_rel * player.cosA - px_rel * player.sinA; // Depth before pitch
// Apply pitch rotation to vertical components
double final_pz = pz_rel * player.cosP - rotY_depth * player.sinP; // New effective Z after pitch
double final_depth = rotY_depth * player.cosP + pz_rel * player.sinP; // New effective depth after pitch
if (final_depth > 0.1) { // Monster is in front of player
double inv_depth = 1.0 / final_depth;
int screenX = int(SCREEN_WIDTH / 2 + rotX * SCREEN_HEIGHT * inv_depth);
int screenY = int(SCREEN_HEIGHT / 2 - final_pz * (SCREEN_HEIGHT/2) * inv_depth);
// Clamp screen coordinates
if (screenX >= 0 && screenX < SCREEN_WIDTH && screenY >= 0 && screenY < SCREEN_HEIGHT) {
// Using 'M' for monster, bright red
draw(screenX, screenY, 'M', RED | FOREGROUND_INTENSITY);
}
}
}
// --- End New ---
// HUD
string hp_str="HP:"+to_string(player.health);
for(int i=0;i<hp_str.size();i++) draw(i,0,hp_str[i],(player.health>50?GREEN:RED));
string tr_str="TREASURES:"+to_string(player.treasures);
for(int i=0;i<tr_str.size();i++) draw(SCREEN_WIDTH-1-tr_str.size()+i,0,tr_str[i],YELLOW);
// Game Timer (elapsed time)
long long currentTime = GetTickCount64(); // 系统启动以来的毫秒数
long long elapsedTime = (currentTime - startTime) / 1000; // Seconds
string time_str = "TIME:" + to_string(elapsedTime) + "s";
for(int i=0;i<time_str.size();i++) draw(0,1,time_str[i],WHITE);
// Show selected block type for placing
string selected_block_str = "PLACE: ";
switch (selectedBlockType) {
case WALL: selected_block_str += "WALL"; break;
case TREASURE: selected_block_str += "TREASURE"; break;
case EXIT: selected_block_str += "EXIT"; break;
case MONSTER: selected_block_str += "MONSTER"; break;
case TRAP: selected_block_str += "TRAP"; break;
default: selected_block_str += "UNKNOWN"; break; // Should not happen
}
for(int i=0;i<selected_block_str.size();i++) draw(SCREEN_WIDTH-1-selected_block_str.size()+i,1,selected_block_str[i],CYAN); // Below treasures
draw(SCREEN_WIDTH/2,halfH_shifted,'+',WHITE); // Crosshair
// Minimap
if(showMiniMap){
// V is the total width/height of the minimap grid (e.g., radius 7 means 15x15)
int V = 2 * minimap_radius + 1;
// Calculate starting position for minimap (top-right, with some padding)
int sx = SCREEN_WIDTH - V - 2; // 2 units padding from right edge
int sy = 3; // 3 units padding from top edge, below HUD
// Draw border
WORD borderColor = GREY;
char borderChar = (char)219; // Solid block character
// Top and Bottom borders
for (int i = 0; i < V + 2; ++i) {
draw(sx - 1 + i, sy - 1, borderChar, borderColor); // Top line
draw(sx - 1 + i, sy + V, borderChar, borderColor); // Bottom line
}
// Left and Right borders
for (int i = 0; i < V + 2; ++i) {
draw(sx - 1, sy - 1 + i, borderChar, borderColor); // Left line
draw(sx + V, sy - 1 + i, borderChar, borderColor); // Right line
}
int cx=static_cast<int>(player.x), cy=static_cast<int>(player.y);
for(int dy=-minimap_radius;dy<=minimap_radius;++dy){ // Loop from -radius to +radius
for(int dx=-minimap_radius;dx<=minimap_radius;++dx){
int wx=cx+dx, wy=cy+dy;
int v=getWorldAt(wx,wy); char c=' '; WORD col;
switch(v){
case WALL: c='#'; col=DARK_GREY; break;
case TREASURE: c='$'; col=YELLOW; break;
case EXIT: c='E'; col=GREEN; break;
case MONSTER: c='M'; col=RED; break;
case TRAP: c='T'; col=DARK_RED; break;
default: c=' '; col=backroomsMode ? YELLOW : BLUE; break; // Empty space color matches sky
}
// Calculate drawing position within the minimap area relative to sx,sy
// NEW: Apply horizontal flip for map tiles
int draw_dx = minimap_flipped ? -dx : dx;
draw(sx + minimap_radius + draw_dx, sy + minimap_radius + dy, c, col);
}
}
// Draw player at the center of the minimap (always at center, not flipped)
draw(sx + minimap_radius, sy + minimap_radius,'@',RED | FOREGROUND_INTENSITY);
// --- NEW: Draw player direction arrow for 8 directions ---
char arrow_char;
int dx_arrow_offset = 0, dy_arrow_offset = 0; // Relative offsets from player's @
double normalized_angle = fmod(player.angle, 2 * PI);
if (normalized_angle < 0) normalized_angle += 2 * PI; // Normalize to 0 to 2PI
// Define 8 sectors of 45 degrees (PI/4) each
// Angles are clockwise from positive X-axis (Right).
// Console Y increases downwards, so 'Up' means negative Y offset, 'Down' means positive Y offset.
// Sector 1: Right (337.5 to 22.5 degrees)
if (normalized_angle >= (15 * PI / 8.0) || normalized_angle < (PI / 8.0)) {
arrow_char = '>';
dx_arrow_offset = 1; dy_arrow_offset = 0;
}
// Sector 2: Up-Right (22.5 to 67.5 degrees)
else if (normalized_angle >= (PI / 8.0) && normalized_angle < (3 * PI / 8.0)) {
arrow_char = '.'; // Top-right dot
dx_arrow_offset = 1; dy_arrow_offset = -1;
}
// Sector 3: Up (67.5 to 112.5 degrees)
else if (normalized_angle >= (3 * PI / 8.0) && normalized_angle < (5 * PI / 8.0)) {
arrow_char = '^';
dx_arrow_offset = 0; dy_arrow_offset = -1;
}
// Sector 4: Up-Left (112.5 to 157.5 degrees)
else if (normalized_angle >= (5 * PI / 8.0) && normalized_angle < (7 * PI / 8.0)) {
arrow_char = '.'; // Top-left dot
dx_arrow_offset = -1; dy_arrow_offset = -1;
}
// Sector 5: Left (157.5 to 202.5 degrees)
else if (normalized_angle >= (7 * PI / 8.0) && normalized_angle < (9 * PI / 8.0)) {
arrow_char = '<';
dx_arrow_offset = -1; dy_arrow_offset = 0;
}
// Sector 6: Down-Left (202.5 to 247.5 degrees)
else if (normalized_angle >= (9 * PI / 8.0) && normalized_angle < (11 * PI / 8.0)) {
arrow_char = '.'; // Bottom-left dot
dx_arrow_offset = -1; dy_arrow_offset = 1;
}
// Sector 7: Down (247.5 to 292.5 degrees)
else if (normalized_angle >= (11 * PI / 8.0) && normalized_angle < (13 * PI / 8.0)) {
arrow_char = 'v';
dx_arrow_offset = 0; dy_arrow_offset = 1;
}
// Sector 8: Down-Right (292.5 to 337.5 degrees)
else { // This covers the range normalized_angle >= (13 * PI / 8.0) && normalized_angle < (15 * PI / 8.0)
arrow_char = '.'; // Bottom-right dot
dx_arrow_offset = 1; dy_arrow_offset = 1;
}
// NEW: Apply horizontal flip for arrow offset
int draw_dx_arrow = minimap_flipped ? -dx_arrow_offset : dx_arrow_offset;
// Draw the direction character at the calculated relative position
draw(sx + minimap_radius + draw_dx_arrow, sy + minimap_radius + dy_arrow_offset, arrow_char, RED | FOREGROUND_INTENSITY);
// --- END NEW ---
}
// --- First write of the buffer (normal frame) ---
WriteConsoleOutputA(hConsole,screen,{SHORT(SCREEN_WIDTH),SHORT(SCREEN_HEIGHT)},bufCoord,&writeRegion);
// === NEW: Damage Flash Effect ===
if (damageFlashTimer > 0.0) {
// Construct a CHAR_INFO for a red background space
CHAR_INFO redCell;
redCell.Char.AsciiChar = ' ';
redCell.Attributes = BACKGROUND_RED | BACKGROUND_INTENSITY; // Bright Red Background
// Fill the entire screen buffer with the red cell
for (int y = 0; y < SCREEN_HEIGHT; ++y) {
for (int x = 0; x < SCREEN_WIDTH; ++x) {
screen[y * SCREEN_WIDTH + x] = redCell;
}
}
// Write the red buffer to the console. This will temporarily overwrite the normal frame.
WriteConsoleOutputA(hConsole, screen, {SHORT(SCREEN_WIDTH), SHORT(SCREEN_HEIGHT)}, bufCoord, &writeRegion);
}
// ================================
}
// Function to clear the console and print message for game over/win
void displayGameEndScreen(const string& message) {
system("cls"); // Clear console
cout << endl << endl;
cout << string((SCREEN_WIDTH - message.length()) / 2, ' ') << message << endl;
cout << string((SCREEN_WIDTH - 25) / 2, ' ') << "Press ENTER to exit." << endl;
cin.ignore(numeric_limits<streamsize>::max(), '\n'); // Clear any leftover input buffer
cin.get();
}
int main(){
SetConsoleTitle("迷迷世界");
srand((unsigned)time(NULL)); // Seed random number generator
ios::sync_with_stdio(false);
system("cls"); // Clear screen for menu
cout << "\n\n";
cout << " --------------------------------------------------\n";
cout << " | 欢迎来到 迷迷世界 |\n";
cout << " | (Maze Runner 3D) |\n";
cout << " --------------------------------------------------\n";
cout << "\n";
cout << " 请选择地图模式：\n";
cout << " 1. 无限自动生成地图 (Infinite procedural map)\n";
cout << " 2. 加载已有地图 (Load existing map from file)\n";
cout << " --------------------------------------------------\n";
cout << " 输入编号并回车：";
int choice_input = 1; // Default choice
cin >> choice_input;
cin.ignore(numeric_limits<streamsize>::max(), '\n'); // Clear rest of line
if (choice_input == 2) {
mapMode = MapMode::Existing;
cout<<"请选择地图：\n";
cout<<"1.空旷的小房间\n";
cout<<"2.石墙林立\n";
string fname_choice_str;
getline(cin, fname_choice_str);
int fname_choice = 0;
try {
fname_choice = stoi(fname_choice_str);
} catch (const std::invalid_argument& ia) {
cerr << "无效输入, 默认为 1.\n";
fname_choice = 1;
} catch (const std::out_of_range& oor) {
cerr << "输入超出范围, 默认为 1.\n";
fname_choice = 1;
}
string fname_base;
if (fname_choice == 1) {
fname_base = "1"; // Corresponding to "空旷的小房间.txt"
} else if (fname_choice == 2) {
fname_base = "2"; // Corresponding to "石墙林立.txt"
} else {
cout << "无效选择，默认为 '空旷的小房间'.\n";
fname_base = "1";
}
loadExistingMap(fname_base + ".txt");
} else {
mapMode = MapMode::Infinite;
cout << " 已选择无限自动生成模式。\n";
}
// Continue with the rest of the game intro and initialization
initConsole(); // Initialize console AFTER getting size input
// !! HERE IS THE FIX !!
// Set console output code page to OEM 437, which contains the block character (char 219)
SetConsoleOutputCP(437);
SetConsoleCP(437); // Also set input code page for consistency (though not strictly needed for this bug)
// !! END OF FIX !!
cout << "\n\n";
cout << " --------------------------------------------------\n";
cout << " | 欢迎来到 迷迷世界 |\n";
cout << " | (Maze Runner 3D) |\n";
cout << " --------------------------------------------------\n";
cout << "\n";
cout << " **游戏概述:**\n";
cout << " 《迷迷世界3D》是一款独特的、在Windows控制台中运行的3D第一人称迷宫冒险游戏。\n";
cout << " 你将身处一个无限生成、不断变化的像素化迷宫中。你的目标是探索、收集宝藏、\n";
cout << " 生存下来并找到出口！\n";
cout << "\n";
cout << " **核心玩法与特色:**\n";
cout << " - **无限迷宫:** 程序生成，每次体验都不同。\n";
cout << " - **动态元素:** 收集'$'宝藏，寻找'E'出口。小心'M'怪物和'T'陷阱，它们会扣除生命！\n";
cout << " - **自由互动:** 按'X'挖掘任何方块，按'1'放置方块，改变迷宫。\n";
cout << " - **辅助模式:** 按'M'切换小地图，按'K'切换独特的“后室”视觉模式。\n";
cout << "\n";
cout << " **操作指南:**\n";
cout << " - **WASD:** 移动 (按住SHIFT冲刺)\n";
cout << " - **空格键 (SPACE):** 跳跃\n";
cout << " - **左/右箭头键:** 水平转向\n";
cout << " - **上/下箭头键:** 垂直俯仰\n";
cout << " - **ALT 键:** 切换鼠标视角模式\n";
cout << " - **M 键:** 切换小地图显示\n";
cout << " - **K 键:** 切换“后室”模式\n";
cout << " - **X 键:** 挖掘前方的任何方块 (除了空地)\n";
cout << " - **1 键:** 在前方空地放置当前选定的方块类型\n";
cout << " - **[ 键 (左方括号):** 循环选择上一个要放置的方块类型\n";
cout << " - **] 键 (右方括号):** 循环选择下一个要放置的方块类型\n";
cout << " - **ESC 键:** 退出游戏\n";
cout << " - **+ 键:** 增大迷你地图尺寸\n";
cout << " - **- 键:** 减小迷你地图尺寸\n";
cout << " - **R 键:** 左右翻转迷你地图显示\n";
cout << "\n";
cout << " --------------------------------------------------\n";
cout << " 准备好了吗？按下 ENTER 键开始冒险...\n";
cin.get(); // 等待用户按下Enter键开始游戏
system("cls");
startTime = GetTickCount64(); // 记录游戏开始时间
bool altPrev=false, mPrev=false, xPrev=false, kPrev=false, rPrev=false; // NEW: rPrev for R key
bool onePrev=false, spacePrev=false;
bool cyclePrevPrev = false, cycleNextPrev = false; // For new cycle keys
bool plusPrev = false, minusPrev = false; // For minimap size
// --- New: For DeltaTime Calculation ---
long long lastFrameTime = GetTickCount64();
// Game loop
while(!gameOver){
long long currentFrameTime = GetTickCount64();
double deltaTime = (currentFrameTime - lastFrameTime) / 1000.0; // Time in seconds
lastFrameTime = currentFrameTime;
// === NEW: Update damage flash timer ===
damageFlashTimer = max(0.0, damageFlashTimer - deltaTime);
// ======================================
// --- Input Handling ---
bool alt=key(VK_MENU);
if(alt&&!altPrev) mouseMode=!mouseMode;
altPrev=alt;
if(mouseMode){
POINT p; GetCursorPos(&p);
int dx=p.x-lastMousePos.x;
int dy=p.y-lastMousePos.y; // For pitch
player.angle+=dx*MOUSE_SENSITIVITY;
player.pitch-=dy*MOUSE_SENSITIVITY; // Negative for inverted Y-axis
SetCursorPos(lastMousePos.x,lastMousePos.y);
}
// Horizontal camera rotation (Yaw)
if(key(VK_LEFT)) player.angle-=KEY_SENSITIVITY;
if(key(VK_RIGHT)) player.angle+=KEY_SENSITIVITY;
// Vertical camera rotation (Pitch)
if(key(VK_UP)) player.pitch+=PITCH_SENSITIVITY;
if(key(VK_DOWN)) player.pitch-=PITCH_SENSITIVITY;
player.pitch = max(-MAX_PITCH_ANGLE, min(MAX_PITCH_ANGLE, player.pitch));
// Movement (WASD)
double nx=player.x, ny=player.y;
double currentMoveSpeed = MOVE_SPEED;
// Optional: Sprint if holding SHIFT
if (key(VK_SHIFT)) currentMoveSpeed *= 1.5;
if(key('W')){ // Forward
nx+=player.cosA*currentMoveSpeed;
ny+=player.sinA*currentMoveSpeed;
}
if(key('S')){ // Backward
nx-=player.cosA*currentMoveSpeed;
ny-=player.sinA*currentMoveSpeed;
}
if(key('A')){ // Strafe Left
nx+=player.sinA*currentMoveSpeed;
ny-=player.cosA*currentMoveSpeed;
}
if(key('D')){ // Strafe Right
nx-=player.sinA*currentMoveSpeed;
ny+=player.cosA*currentMoveSpeed;
}
// Basic collision detection for horizontal movement
// Check corners of player's bounding box
double player_half_width = 0.2; // Player's effective half-width for collision
// Proposed new position (x component only)
bool can_move_x = (
getWorldAt(static_cast<int>(nx - player_half_width), static_cast<int>(player.y - player_half_width)) != WALL &&
getWorldAt(static_cast<int>(nx + player_half_width), static_cast<int>(player.y - player_half_width)) != WALL &&
getWorldAt(static_cast<int>(nx - player_half_width), static_cast<int>(player.y + player_half_width)) != WALL &&
getWorldAt(static_cast<int>(nx + player_half_width), static_cast<int>(player.y + player_half_width)) != WALL
);
// Proposed new position (y component only)
bool can_move_y = (
getWorldAt(static_cast<int>(player.x - player_half_width), static_cast<int>(ny - player_half_width)) != WALL &&
getWorldAt(static_cast<int>(player.x + player_half_width), static_cast<int>(ny - player_half_width)) != WALL &&
getWorldAt(static_cast<int>(player.x - player_half_width), static_cast<int>(ny + player_half_width)) != WALL &&
getWorldAt(static_cast<int>(player.x + player_half_width), static_cast<int>(ny + player_half_width)) != WALL
);
// Apply movement if no collision
if (can_move_x) player.x = nx;
if (can_move_y) player.y = ny;
// Jump
bool space = key(VK_SPACE);
if(space && !spacePrev && player.onGround){
player.vz = JUMP_FORCE;
player.onGround = false;
// playSound("jump.wav"); // Requires jump.wav file
}
spacePrev = space;
// Apply gravity
if(!player.onGround) {
player.vz -= GRAVITY;
player.z += player.vz;
}
// Collision with floor (z=0)
if(player.z <= PLAYER_HEIGHT){
player.z = PLAYER_HEIGHT;
player.vz = 0;
player.onGround = true;
}
// Minimap toggle
if(key('M')&&!mPrev) showMiniMap=!showMiniMap;
mPrev=key('M');
// K key toggle for backrooms mode
if(key('K')&&!kPrev) backroomsMode=!backroomsMode;
kPrev=key('K');
// R key toggle for minimap flip (NEW)
bool r = key('R');
if(r && !rPrev) minimap_flipped = !minimap_flipped;
rPrev = r;
// Cycle selected block type for placing
bool cyclePrev = key(VK_OEM_4); // VK_OEM_4 is '['
bool cycleNext = key(VK_OEM_6); // VK_OEM_6 is ']'
const int min_placeable_type = WALL; // BlockType::WALL (1)
const int max_placeable_type = TRAP; // BlockType::TRAP (5)
const int num_placeable_types = max_placeable_type - min_placeable_type + 1; // 5 types
if(cyclePrev && !cyclePrevPrev){
selectedBlockType = (BlockType)(((selectedBlockType - min_placeable_type - 1 + num_placeable_types) % num_placeable_types) + min_placeable_type);
// playSound("change_block.wav"); // Requires sound
}
if(cycleNext && !cycleNextPrev){
selectedBlockType = (BlockType)(((selectedBlockType - min_placeable_type + 1) % num_placeable_types) + min_placeable_type);
// playSound("change_block.wav"); // Requires sound
}
cyclePrevPrev = cyclePrev;
cycleNextPrev = cycleNext;
// --- NEW: Minimap size change ---
bool plus = key(VK_OEM_PLUS); // For '+' key
bool minus = key(VK_OEM_MINUS); // For '-' key
if (plus && !plusPrev) {
minimap_radius = min(MAX_MINIMAP_RADIUS, minimap_radius + 1);
}
if (minus && !minusPrev) {
minimap_radius = max(MIN_MINIMAP_RADIUS, minimap_radius - 1);
}
plusPrev = plus;
minusPrev = minus;
// --- END NEW ---
// --- Interaction Logic ---
// Player's current tile (player.x, player.y are the coordinates for the center of the player,
// static_cast<int> takes the integer part, effectively the bottom-left corner of the tile)
int current_tile_x = static_cast<int>(player.x);
int current_tile_y = static_cast<int>(player.y);
int current_tile_type = getWorldAt(current_tile_x, current_tile_y);
if (current_tile_type == TREASURE) {
player.treasures++;
setWorldAt(current_tile_x, current_tile_y, EMPTY); // Consume treasure
// playSound("collect.wav"); // Requires collect.wav file
} else if (current_tile_type == EXIT) {
gameOver = true; // Game over, player won
gameEndReason = 1; // Set win reason
} else if (current_tile_type == MONSTER || current_tile_type == TRAP) {
player.health -= 10; // Take damage
// === NEW: Trigger red flash on damage ===
damageFlashTimer = DAMAGE_FLASH_DURATION;
// ========================================
if (player.health < 0) player.health = 0; // Cap health at 0
setWorldAt(current_tile_x, current_tile_y, EMPTY); // Remove monster/trap after damage
// playSound("hit.wav"); // Requires hit.wav file
// --- New: If it was a monster, remove it from the dynamic list ---
if (current_tile_type == MONSTER) {
// Iterate backwards to safely erase
for (int i = monsters.size() - 1; i >= 0; --i) {
// Check if this monster object is at the tile where player took damage
// Monster coordinates are centered (X.5), static_cast<int> gives tile index.
if (static_cast<int>(monsters[i].x) == current_tile_x && static_cast<int>(monsters[i].y) == current_tile_y) {
monsters.erase(monsters.begin() + i);
break; // Found and removed, exit loop
}
}
}
// --- End New ---
}
if (player.health <= 0) {
gameOver = true; // Game over, player lost
gameEndReason = 2; // Set lose reason
}
// Calculate target tile for digging/placing
// Assuming 1.5 units in front for interaction distance.
int target_tile_x = static_cast<int>(player.x + player.cosA * 1.5);
int target_tile_y = static_cast<int>(player.y + player.sinA * 1.5);
// Prevent targeting own tile
if (target_tile_x == current_tile_x && target_tile_y == current_tile_y) {
// Don't interact with own tile for digging/placing
} else {
// Digging (X key) - now destroys any non-empty block
if(key('X') && !xPrev){
int block_to_destroy = getWorldAt(target_tile_x, target_tile_y);
if(block_to_destroy != EMPTY){ // Destroy any non-empty block
setWorldAt(target_tile_x, target_tile_y, EMPTY);
// --- New: If it was a monster, also remove from dynamic list ---
if (block_to_destroy == MONSTER) {
// Iterate backwards to safely erase
for (int i = monsters.size() - 1; i >= 0; --i) {
if (static_cast<int>(monsters[i].x) == target_tile_x && static_cast<int>(monsters[i].y) == target_tile_y) {
monsters.erase(monsters.begin() + i);
break;
}
}
}
// --- End New ---
// Add particle effects based on destroyed block type
char p_char = '#';
WORD p_color = DARK_GREY;
switch (block_to_destroy) {
case WALL: p_char = '#'; p_color = DARK_GREY; break;
case TREASURE: p_char = '$'; p_color = YELLOW; break;
case EXIT: p_char = 'E'; p_color = GREEN; break;
case MONSTER: p_char = 'M'; p_color = RED; break; // Monster particles
case TRAP: p_char = 'T'; p_color = DARK_RED; break; // Trap particles
}
for(int i=0; i<10; ++i){
double px = target_tile_x + 0.5;
double py = target_tile_y + 0.5;
double pz = player.z; // Start particles around player's height
double angle = (double)rand()/RAND_MAX * PI * 2;
double speed = (double)rand()/RAND_MAX * 0.2 + 0.05;
double vz_p = (double)rand()/RAND_MAX * 0.1 + 0.05;
particles.push_back({
px, py, pz,
cos(angle) * speed, sin(angle) * speed, vz_p,
30, p_char, p_color
});
}
// playSound("dig.wav"); // Requires dig.wav file
}
}
// Placing Selected Block Type (1 key)
if (key('1') && !onePrev) {
if (getWorldAt(target_tile_x, target_tile_y) == EMPTY) { // Only place on empty
// --- New: If placing a monster, add to dynamic list as well ---
if (selectedBlockType == MONSTER) {
monsters.push_back({
(double)target_tile_x + 0.5,
(double)target_tile_y + 0.5,
MONSTER_MOVE_DELAY,
(int)monsters.size()
});
}
// --- End New ---
setWorldAt(target_tile_x, target_tile_y, selectedBlockType);
// playSound("place.wav"); // Requires place.wav file
}
}
}
xPrev = key('X');
onePrev = key('1');
// --- New: Monster AI Update ---
for (int i = 0; i < monsters.size(); ++i) {
Monster& m = monsters[i];
m.moveCooldown -= deltaTime; // Reduce cooldown time
int old_mx = static_cast<int>(m.x); // Current tile of monster
int old_my = static_cast<int>(m.y);
double dx = player.x - m.x;
double dy = player.y - m.y;
double dist_to_player_sq = dx*dx + dy*dy; // Use squared distance for efficiency
// Only move if within detection range (squared for efficiency) and cooldown is ready
if (dist_to_player_sq <= MONSTER_DETECTION_RANGE * MONSTER_DETECTION_RANGE && m.moveCooldown <= 0) {
m.moveCooldown = MONSTER_MOVE_DELAY; // Reset cooldown
int dir_x = 0;
if (dx > 0.1) dir_x = 1; // Small threshold to avoid issues with dx exactly 0
else if (dx < -0.1) dir_x = -1;
int dir_y = 0;
if (dy > 0.1) dir_y = 1;
else if (dy < -0.1) dir_y = -1;
bool moved_this_turn = false;
// Priority:
// 1. Try to move diagonally (both X and Y directions) if player is not directly axial.
// 2. If diagonal fails or not applicable, try moving along the X-axis.
// 3. If X-axis fails, try moving along the Y-axis.
// Attempt 1: Diagonal move (if both X and Y movement are desired)
if (dir_x != 0 && dir_y != 0) {
moved_this_turn = tryMoveMonster(m, old_mx, old_my, old_mx + dir_x, old_my + dir_y);
}
// Attempt 2: Axial X move (if not already moved diagonally or if only X movement is desired)
if (!moved_this_turn && dir_x != 0) {
moved_this_turn = tryMoveMonster(m, old_mx, old_my, old_mx + dir_x, old_my);
}
// Attempt 3: Axial Y move (if not already moved by any previous attempts or if only Y movement is desired)
if (!moved_this_turn && dir_y != 0) {
moved_this_turn = tryMoveMonster(m, old_mx, old_my, old_mx, old_my + dir_y);
}
}
}
// --- End Monster AI Update ---
// --- Particle Update ---
for (int i = particles.size() - 1; i >= 0; --i) {
Particle& p = particles[i];
p.x += p.vx;
p.y += p.vy;
p.z += p.vz;
p.vz -= PARTICLE_GRAVITY;
p.vx *= PARTICLE_FRICTION;
p.vy *= PARTICLE_FRICTION;
p.vz *= PARTICLE_FRICTION;
p.life--;
if (p.life <= 0) {
particles.erase(particles.begin() + i);
}
}
// --- Render Frame ---
renderFrame();
// --- Exit Condition ---
if(key(VK_ESCAPE)) {
gameOver = true; // Manual exit
gameEndReason = 0; // Set manual exit reason
break;
}
// --- Frame Rate Control ---
Sleep(15); // Using deltaTime for monster movement, fixed Sleep less critical. Can be used for overall frame rate cap.
}
// Now, determine game end message based on gameEndReason
if (gameEndReason == 2) { // Player lost (health <= 0)
displayGameEndScreen("GAME OVER! You ran out of health. Time: " + to_string((GetTickCount64() - startTime) / 1000) + "s");
} else if (gameEndReason == 1) { // Player won (reached exit)
displayGameEndScreen("YOU ESCAPED! Treasures collected: " + to_string(player.treasures) + ". Time: " + to_string((GetTickCount64() - startTime) / 1000) + "s");
} else { // Manual exit (gameEndReason == 0)
displayGameEndScreen("Thanks for playing!");
}
free(screen);
return 0;
}