333 lines
12 KiB
C++
333 lines
12 KiB
C++
#ifndef TDGAME_MAP_HPP
|
|
#define TDGAME_MAP_HPP
|
|
|
|
#include "tile.hpp"
|
|
#include "enemy.hpp"
|
|
#include "tower.hpp"
|
|
#include "customjson.hpp"
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <map>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <queue>
|
|
#include <cmath>
|
|
#include <algorithm>
|
|
|
|
namespace fs = std::filesystem;
|
|
|
|
// A simple struct to represent a point on the grid.
|
|
struct GridPoint {
|
|
int x, z;
|
|
bool operator==(const GridPoint& other) const { return x == other.x && z == other.z; }
|
|
bool operator<(const GridPoint& other) const { return x < other.x || (x == other.x && z < other.z); }
|
|
};
|
|
|
|
// Represents the entire game map, managing tiles, entities, and game state.
|
|
class GameMap {
|
|
private:
|
|
int _width = 0;
|
|
int _height = 0;
|
|
std::vector<std::vector<Tile>> _tiles;
|
|
|
|
std::vector<std::unique_ptr<Enemy>> _enemies;
|
|
std::vector<std::unique_ptr<Tower>> _towers;
|
|
|
|
std::vector<GridPoint> _spawnPoints;
|
|
std::vector<GridPoint> _basePoints;
|
|
GridPoint _primaryBaseTarget; // A single target for pathfinding simplicity
|
|
|
|
int _playerHealth = 100;
|
|
int _currentWave = 0;
|
|
bool _gameOver = false;
|
|
|
|
// Internal helper for A* pathfinding
|
|
struct PathNode {
|
|
GridPoint pos;
|
|
float g_cost = 0; // Cost from start
|
|
float h_cost = 0; // Heuristic cost to end
|
|
GridPoint parent;
|
|
|
|
float f_cost() const { return g_cost + h_cost; }
|
|
|
|
// For priority queue ordering
|
|
bool operator>(const PathNode& other) const { return f_cost() > other.f_cost(); }
|
|
};
|
|
|
|
public:
|
|
GameMap() = default;
|
|
int _playerMoney = 250;
|
|
|
|
// --- Primary Methods ---
|
|
|
|
// Loads a map definition from a JSON file.
|
|
bool loadFromFile(const std::string& filepath) {
|
|
std::ifstream f(filepath);
|
|
if (!f.is_open()) {
|
|
std::cerr << "GameMap: Failed to open map file: " << filepath << std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::stringstream buffer;
|
|
buffer << f.rdbuf();
|
|
|
|
try {
|
|
customJson::Node root = customJson::parse(buffer.str());
|
|
const auto& j = root.as_object();
|
|
|
|
_width = j.at("width").as_double();
|
|
_height = j.at("height").as_double();
|
|
_playerHealth = j.at("start_health").as_double();
|
|
_playerMoney = j.at("start_money").as_double();
|
|
|
|
const auto& key_obj = j.at("tile_key").as_object();
|
|
std::map<char, std::string> tileKey;
|
|
for(const auto& pair : key_obj) {
|
|
tileKey[pair.first[0]] = pair.second.as_string();
|
|
}
|
|
|
|
const auto& layout = j.at("layout").as_array();
|
|
_tiles.assign(_height, std::vector<Tile>(_width));
|
|
_spawnPoints.clear();
|
|
_basePoints.clear();
|
|
|
|
for (int z = 0; z < _height; ++z) {
|
|
std::string row_str = layout[z].as_string();
|
|
std::stringstream row_stream(row_str);
|
|
char tileChar;
|
|
for (int x = 0; x < _width; ++x) {
|
|
row_stream >> tileChar;
|
|
if (tileKey.count(tileChar)) {
|
|
std::string tileId = tileKey.at(tileChar);
|
|
_tiles[z][x] = TileRegistry::getInstance().createTile(tileId, x, z);
|
|
|
|
if (_tiles[z][x].type == TileType::SPAWN) {
|
|
_spawnPoints.push_back({x, z});
|
|
} else if (_tiles[z][x].type == TileType::BASE) {
|
|
_basePoints.push_back({x, z});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!_basePoints.empty()) {
|
|
_primaryBaseTarget = _basePoints[0]; // Simple pathfinding target
|
|
} else {
|
|
std::cerr << "GameMap: Warning, map has no base tiles defined." << std::endl;
|
|
}
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "GameMap: JSON parse error in " << filepath << ": " << e.what() << std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::cout << "GameMap: Successfully loaded map '" << filepath << "'." << std::endl;
|
|
return true;
|
|
}
|
|
|
|
// The main game loop tick function.
|
|
void update(float deltaTime) {
|
|
if (_gameOver) return;
|
|
|
|
handleSpawning(deltaTime);
|
|
|
|
for (auto& tower : _towers) {
|
|
tower->update(deltaTime, _enemies);
|
|
}
|
|
|
|
for (auto& enemy : _enemies) {
|
|
if (enemy->update(deltaTime)) {
|
|
// Enemy reached the base
|
|
_playerHealth -= enemy->baseDamage;
|
|
if (_playerHealth <= 0) {
|
|
_playerHealth = 0;
|
|
_gameOver = true;
|
|
std::cout << "Game Over!" << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Cleanup dead/finished enemies
|
|
auto initialSize = _enemies.size();
|
|
_enemies.erase(std::remove_if(_enemies.begin(), _enemies.end(),
|
|
[this](const std::unique_ptr<Enemy>& e) {
|
|
if (!e->isAlive()) {
|
|
if (e->hp <= 0) { // Died to a tower
|
|
this->_playerMoney += e->reward;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}),
|
|
_enemies.end());
|
|
}
|
|
|
|
// Handles player action to build a tower.
|
|
bool buildTower(const std::string& towerId, int x, int z) {
|
|
if (isOutOfBounds(x, z) || !_tiles[z][x].isBuildable()) {
|
|
return false;
|
|
}
|
|
|
|
const TowerPrototype* proto = TowerRegistry::getInstance().getPrototype(towerId);
|
|
if (!proto || _playerMoney < proto->baseCost) {
|
|
return false;
|
|
}
|
|
|
|
_playerMoney -= proto->baseCost;
|
|
Vector3f position(static_cast<float>(x), 0.0f, static_cast<float>(z));
|
|
auto newTower = TowerRegistry::getInstance().createTower(towerId, position);
|
|
if (newTower) {
|
|
_towers.push_back(std::move(newTower));
|
|
// Mark tile as occupied - a simple approach
|
|
_tiles[z][x].type = TileType::SPECIAL; // Mark as non-buildable
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Calculates a path from start to end using A*.
|
|
std::vector<Vector3f> findPath(GridPoint start, GridPoint end, EnemyType enemyType) {
|
|
std::vector<Vector3f> path;
|
|
std::priority_queue<PathNode, std::vector<PathNode>, std::greater<PathNode>> openSet;
|
|
std::map<GridPoint, PathNode> allNodes;
|
|
|
|
PathNode startNode;
|
|
startNode.pos = start;
|
|
startNode.g_cost = 0;
|
|
startNode.h_cost = std::abs(start.x - end.x) + std::abs(start.z - end.z); // Manhattan distance
|
|
openSet.push(startNode);
|
|
allNodes[start] = startNode;
|
|
|
|
GridPoint neighbors[] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; // 4-directional movement
|
|
|
|
while (!openSet.empty()) {
|
|
PathNode current = openSet.top();
|
|
openSet.pop();
|
|
|
|
if (current.pos == end) {
|
|
// Reconstruct path
|
|
GridPoint temp = current.pos;
|
|
while (!(temp == start)) {
|
|
path.push_back(Vector3f(temp.x, 0, temp.z));
|
|
temp = allNodes.at(temp).parent;
|
|
}
|
|
path.push_back(Vector3f(start.x, 0, start.z));
|
|
std::reverse(path.begin(), path.end());
|
|
return path;
|
|
}
|
|
|
|
for (const auto& offset : neighbors) {
|
|
GridPoint neighborPos = {current.pos.x + offset.x, current.pos.z + offset.z};
|
|
|
|
if (isOutOfBounds(neighborPos.x, neighborPos.z) || !isTilePassable(neighborPos.x, neighborPos.z, enemyType)) {
|
|
continue;
|
|
}
|
|
|
|
float new_g_cost = current.g_cost + 1.0f; // Assuming cost is 1 per tile for now
|
|
|
|
if (allNodes.find(neighborPos) == allNodes.end() || new_g_cost < allNodes[neighborPos].g_cost) {
|
|
PathNode neighborNode;
|
|
neighborNode.pos = neighborPos;
|
|
neighborNode.parent = current.pos;
|
|
neighborNode.g_cost = new_g_cost;
|
|
neighborNode.h_cost = std::abs(neighborPos.x - end.x) + std::abs(neighborPos.z - end.z);
|
|
allNodes[neighborPos] = neighborNode;
|
|
openSet.push(neighborNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
return {}; // Return empty path if none found
|
|
}
|
|
|
|
// --- Accessors ---
|
|
int getWidth() const { return _width; }
|
|
int getHeight() const { return _height; }
|
|
int getPlayerHealth() const { return _playerHealth; }
|
|
int getPlayerMoney() const { return _playerMoney; }
|
|
bool isGameOver() const { return _gameOver; }
|
|
const Tile& getTile(int x, int z) const { return _tiles[z][x]; }
|
|
const std::vector<std::unique_ptr<Enemy>>& getEnemies() const { return _enemies; }
|
|
const std::vector<std::unique_ptr<Tower>>& getTowers() const { return _towers; }
|
|
|
|
|
|
private:
|
|
// --- Private Helpers ---
|
|
|
|
void handleSpawning(float deltaTime) {
|
|
for (const auto& sp : _spawnPoints) {
|
|
Tile& spawnTile = _tiles[sp.z][sp.x];
|
|
if (!spawnTile.spawn.has_value()) continue;
|
|
|
|
SpawnProperties& props = *spawnTile.spawn;
|
|
if (props.currentWaveIndex >= props.waves.size()) {
|
|
if(props.loopWaves) {
|
|
// Loop waves with scaling
|
|
props.currentWaveIndex = 0;
|
|
for(auto& wave : props.waves) {
|
|
wave.healthMult += props.loopHealthScaler;
|
|
wave.speedMult += props.loopSpeedScaler;
|
|
}
|
|
} else {
|
|
continue; // No more waves
|
|
}
|
|
}
|
|
|
|
WaveDefinition& currentWave = props.waves[props.currentWaveIndex];
|
|
// Simple logic: spawn one enemy per interval if count > 0
|
|
// A more robust system would use a timer.
|
|
static float spawnCooldown = 0.0f;
|
|
spawnCooldown -= deltaTime;
|
|
|
|
if (spawnCooldown <= 0 && currentWave.count > 0) {
|
|
spawnEnemy(currentWave, sp);
|
|
currentWave.count--;
|
|
spawnCooldown = currentWave.interval;
|
|
|
|
if (currentWave.count <= 0) {
|
|
props.currentWaveIndex++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void spawnEnemy(const WaveDefinition& waveDef, const GridPoint& spawnPos) {
|
|
Vector3f startPosition(static_cast<float>(spawnPos.x), 0.0f, static_cast<float>(spawnPos.z));
|
|
auto enemy = EnemyRegistry::getInstance().createEnemy(waveDef.enemyId, startPosition);
|
|
if (!enemy) return;
|
|
|
|
// Apply wave multipliers
|
|
enemy->maxHp *= waveDef.healthMult;
|
|
enemy->hp = enemy->maxHp;
|
|
enemy->speed *= waveDef.speedMult;
|
|
enemy->reward = static_cast<int>(enemy->reward * waveDef.rewardMult);
|
|
|
|
auto path = findPath(spawnPos, _primaryBaseTarget, enemy->type);
|
|
if (path.empty()) {
|
|
std::cerr << "GameMap: Could not find path for enemy " << waveDef.enemyId << std::endl;
|
|
return;
|
|
}
|
|
|
|
enemy->setPath(path);
|
|
_enemies.push_back(std::move(enemy));
|
|
}
|
|
|
|
bool isOutOfBounds(int x, int z) const {
|
|
return x < 0 || x >= _width || z < 0 || z >= _height;
|
|
}
|
|
|
|
bool isTilePassable(int x, int z, EnemyType type) const {
|
|
const auto& tile = _tiles[z][x];
|
|
if (tile.path.has_value()) {
|
|
return (type == EnemyType::GROUND && tile.path->isGroundPath) || (type == EnemyType::AIR && tile.path->isFlyingPath);
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
#endif |